Aprendiendo JAVA

Aprenda Java

Aprenda 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

Aprenda Java

6.

7.

8.

9.

5.1. Métodos de la clase Math......................................................................................95 5.2. Formateo de la salida............................................................................................97 5.3. Métodos de la clase String....................................................................................99 5.4. Formateo de números.........................................................................................100 Métodos......................................................................................................................102 6.1. Programación modular........................................................................................102 6.2. Métodos void.......................................................................................................102 6.3. Métodos void sin parámetros..............................................................................102 6.4. Métodos void con parámetros.............................................................................104 6.5. Métodos return.....................................................................................................105 6.6. Métodos return sin parámetros...........................................................................106 6.7. Métodos return con parámetros..........................................................................106 6.8. Compatibilidad de argumentos y parámetros.....................................................110 6.9. Métodos sobrecargados (overload).....................................................................111 6.10. El ámbito de las variables..................................................................................113 6.11. Ejercicios resueltos............................................................................................115 Arreglos unidimensionales.........................................................................................124 7.1. Declarar, crear y asignar valores a un arreglo unidimensional...........................124 7.2. Operaciones básicas con arreglos unidimensionales.........................................127 7.3. Paso de arreglos unidimensionales a los métodos.............................................131 7.4. Arreglos unidimensionales como valor de retorno..............................................132 7.5. Lista de argumentos de longitud variable...........................................................133 7.6. La clase Arrays....................................................................................................134 7.7. Ejercicios resueltos..............................................................................................137 Arreglos bidimensionales...........................................................................................143 8.1. Declarar, crear y asignar valores a un arreglo bidimensional.............................143 8.2. Operaciones básicas con arreglos bidimensionales...........................................146 8.3. Paso de arreglos bidimensionales a los métodos...............................................151 8.4. Ejercicios resueltos..............................................................................................152 Bibliografía consultada...............................................................................................159

4

Aprenda Java

1. Introducción a Java. Al finalizar esta lección, serás capaz de: • • • •

Conocer las etapas de desarrollo de un programa Java. Descargar e instalar el software para el desarrollo de programas Java. Identificar la estructura básica de un programa en Java. Escribir programas simples en Java.

1.1. El lenguaje Java. Java es un lenguaje de programación orientado a objetos, desarrollado por Sun Microsystems en la década de 1990. Moldeado en base a C++, el lenguaje Java se diseñó para ser pequeño, 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). En la actualidad Java es un lenguaje muy cotizado. Podemos comparar Java respecto a otros lenguajes de programación en la página Web: http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

1.2. Etapas de desarrollo de un programa en Java. Para desarrollar un programa en Java tenemos que pasar por las siguientes etapas: edición, compilación y ejecución. En la etapa de edició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 .java. Así, por ejemplo, el archivo podría llamarse Saludo.java. A este programa escrito en Java se denomina código fuente y para escribirlo se puede recurrir a cualquier editor de texto. En la etapa de compilación, se traduce el código fuente usando el compilador de Java, que es un programa denominado javac.exe, con lo que se obtiene un nuevo código conocido como código de bytes (bytecodes en inglés), que tiene el mismo nombre que el archivo de código fuente, pero con la extensión .class. Así, si el archivo de código fuente se denomina Saludo.java, el código de bytes quedará almacenado automáticamente en un archivo denominado Saludo.class. En la etapa de ejecución, el código de bytes es ejecutado por la Máquina Virtual de Java (JVM, por sus siglas en inglés). El código de bytes es el lenguaje de la JVM. Existe una JVM para cada plataforma (para cada sistema operativo); pero, todas las JVM pueden ejecutar el mismo código de bytes. Así, el código de bytes es independiente de la plataforma. Esto 5

Aprenda Java hace que los programas Java puedan ser ejecutados en cualquier máquina que disponga de una JVM. Actualmente, existe una JVM para la mayor parte de las plataformas, lo que garantiza que los programas Java sean ampliamente portables.

1.3. Software para el desarrollo de programas en Java. Para el desarrollo de programas Java es necesario descargar e instalar la Plataforma Java en su edición estándar que lo obtenemos de : http://www.oracle.com/technetwork/java/javase/downloads/index.html También necesitaremos un entorno de desarrollo integrado (IDE por sus siglas en inglés). Entre los más populares tenemos: • • •

NetBeans: www.netbeans.og Eclipse: www.eclipse.org BlueJ: www.bluej.org.

1.4. Estructura básica de un programa en Java. Empezaremos el proceso de aprendizaje de Java definiendo la estructura básica de un programa en Java. El programa siguiente, HolaMundo.java, declara una clase. public class HolaMundo { }

Todo programa en Java consiste de, cuando menos una declaración de clase: public class HolaMundo. La palabra clave class introduce una declaración de clase, la cual debe ir seguida por el nombre de la clase. Las palabras clave o palabras reservadas se reservan para uso exclusivo de Java y siempre se escriben en minúscula. El nombre de una clase es un identificador. Un identificador es una serie de caracteres que pueden ser letras, dígitos, guiones bajos (_) y signos de moneda ($) que no comience con un dígito ni tenga espacios. Debemos de tener en cuenta que Java es sensible a mayúsculas y minúsculas; es decir, las letras mayúsculas y minúsculas en un identificador son distintas. Cada clase comienza con la palabra clave public. Al guardar este código, el nombre de ese archivo debe coincidir con el nombre de la clase. Por ejemplo: HolaMundo.java Una llave izquierda {, comienza con el cuerpo de todas las declaraciones de clases. Su correspondiente llave derecha }, debe terminar con la declaración de una clase. A las llaves { y } se les conoce como bloque. Un bloque puede contener o anidar otros bloques. 6

Aprenda Java Todo programa en Java debe de contener un método principal al que se le denomina main. Se dice entonces que una aplicación en Java es un programa que contiene el método main. El programa siguiente, HolaMundo.java incorpora la definición del método main. public class HolaMundo { public static void main(String[] args) { } }

El método main es el punto de inicio de toda aplicación en Java. Los paréntesis después del identificador main indican que este es un método. La palabra clave void indica que este método realizará una tarea, pero no devolverá ningún tipo de información cuando complete su tarea. Las palabras String[] args entre paréntesis son una parte requerida de la declaración del método main. 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. 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. El programa siguiente, HolaMundo.java, imprime un mensaje de texto en la consola de salida. /* Programa: HolaMundo.java Propósito: Imprimir un mensaje en la consola de salida. */ public class HolaMundo { // el método main inicia la ejecución del programa public static void main(String[] args) { System.out.println("¡Hola Mundo!"); } // fin del método main } // fin de la clase HolaMundo

Los comentarios ayudan a documentar un programa y mejorar su legibilidad. El compilador de Java ignora estos comentarios. Un comentario que comienza con // se llama comentario de fin de línea (o de una sóla línea). Los comentarios tradicionales (o de múltiples líneas) se distribuyen en varias líneas y comienza con el delimitador /* y termina con */. La línea: System.out.println("¡Hola Mundo!"); es una instrucción. Todas las instrucciones en Java termina con un punto y coma (;). Esta instrucción le indica a la computadora que imprima la cadena de caracteres contenidas entre los caracteres de comillas dobles (sin incluirlas). A una cadena también se le denomina cadena de caracteres, mensaje o literal de cadena. System.out se conoce como objeto de salida 7

Aprenda Java estándar. El método println de System.out imprime una línea de texto en la consola de salida (ventana de comandos, línea de comandos, shell, etc.). La cadena dentro de paréntesis es el argumento para el método. Al escribir los primeros programas en Java es común cometer errores de sintaxis. Un error de sintaxis es una violación a las reglas del lenguaje. El programa siguiente, HolaMundo.java, tiene errores de sintaxis por lo tanto no funcionará hasta que esos errores hayan sido identificados y corregidos. //No respetar la condición mayúscula/minúscula //Es común escribir con mayúsculas: public, class, static, main, etc. //Omitir los pares de { y }, ( y ) //Omitir el punto y coma //Omitir los pares de comillas dobles “ y “ Public class HolaMundo { // el método main inicia la ejecución del programa public static Void main(String[] args) { system.out.println("¡Hola Mundo!); } // 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; también hay que escribir todos los símbolos que aparecen en el código del programa. Por lo tanto el programa anterior no funciona.

1.5 Instrucciones básicas para imprimir texto. Para hacer que un programa imprima una línea de texto necesitamos utilizar el método println/print de System.out y pasarle como argumento entre comillas dobles el texto que queremos desplegar en la pantalla de la computadora. El programa siguiente, Saludo.java utiliza instrucciones print/println para mostrar texto. //Ejemplo con print/println. public class Saludo { public static void main(String[] args) { System.out.print("¡Bienvenido al "); System.out.println("curso de programación con Java!"); } // fin del método main } // fin de la clase Saludo

El método print y println se utilizan para mostrar texto. La diferencia es que println da un salto de línea. Las cadenas pueden incluir caracteres especiales como el de una nueva línea para indicarle a los métodos print y println de System.out cuándo deben colocar el cursor de salida al 8

Aprenda Java inicio de la siguiente línea en el monitor de la computadora. Mensaje.java, utiliza secuencias de escape para imprimir texto.

El programa siguiente,

//Ejemplo de secuencias de escape. public class Mensaje { public static void main(String[] args) { System.out.println("¡Bienvenido\nal\nMundo\nJava!"); } // fin del método main } // fin de la clase Mensaje

La barra diagonal inversa (\) se conoce como carácter de escape. Este carácter indica a los métodos print y println que se va a imprimir un carácter especial. A este carácter se le conoce como secuencia de escape. La secuencia de escape \n representa el carácter de una nueva línea. Veamos otro ejemplo, el programa siguiente, ImprimirTexto.java, muestra algunas secuencias de escape comunes. //Imprimir texto con secuencias de escape. public class ImprimirTexto { // el método main empieza la ejecución de la aplicación en Java public static void main(String[] args) { System.out.print("Linea 01\nLinea 02\nLinea 03\nLinea 04"); System.out.print("\nTab 01\tTab 02\tTab 03\tTab 04"); System.out.print("\nEstoy aprendiendo \"Java\""); System.out.print("\nRuta de BlueJ: c:\\BlueJ"); } // fin del método main } // fin de la clase ImprimirTexto

La secuencia de escape \n representa una nueva línea. El tabulador horizontal está compuesto por \t. Para imprimir una diagonal \ utilizamos \\. Y si queremos imprimir un texto entre comillas dobles utilizamos la \” y \”. En este curso vamos a utilizar frecuentemente la instrucción printf para dar formato al texto. El programa siguiente, Bienvenido.java, utiliza el método printf. //Ejemplo con printf. public class Bienvenido { public static void main(String[] args) { System.out.printf("%s\n%s\n", "¡Bienvenido al", "tutorial de Java!"); } // fin del método main } // fin de la clase Bienvenido

La f en el nombre printf representa la palabra “formato”. La llamada al método printf especifica tres argumentos. Cuando un método requiere varios argumentos, éstos se separan con comas (,); a esto se le conoce como lista separada por comas. El primer 9

Aprenda Java argumento del método printf es una cadena de formato que puede consistir en texto fijo y especificadores de formato. Cada especificador de formato es un receptáculo para un valor, y especifica el tipo de datos a imprimir. Los especificadores de formato empiezan con un signo porcentual (%) y van seguidos de un carácter que representa el tipo de datos. El especificador de formato %s es un receptáculo para una cadena. La cadena de formato especifica que printf debe imprimir dos cadenas, y que cada cadena le debe seguir un carácter de nueva línea. El programa siguiente, Aritmetica.java, utiliza el método printf para imprimir números enteros y en punto flotante. //Utiliza printf para imprimir números. public class Aritmetica { public static void main(String[] args) { System.out.printf("%d + %d = %d\n", 5, 3, 5 + 3); System.out.printf("%f + %f = %f\n", 5.5, 3.5, 5.5 + 3.5); // esto es un error, el especificador de formato es incorrecto // System.out.printf("%d + %d = %d\n", 5.5, 3, 5 + 3); // cuando manejamos números hay que cuidar // la división por cero, // se genera un error en tiempo de ejecución // System.out.printf("%d / %d = %d\n", 5, 0, 5 / 0 ); } // fin del método main } // fin de la clase Aritmetica

10

Aprenda Java

2. Programas simples. Al finalizar esta lección, serás capaz de: •

Escribir programas simples en Java que reciban valores desde el teclado y realicen cálculos aritméticos.

2.1. Escribir un programa simple. El proceso de aprendizaje para resolver problemas mediante un lenguaje de programación pasa por la etapa de resolver y codificar cientos de programas. Veamos un primer ejemplo de muchos. El programa siguiente, AreaCirculo.java, calcula el área de un círculo. //Calcula el área de un círculo. public class AreaCirculo { public static void main(String[] args) { // declaración de variables double radio; double area; // asigna el valor al radio radio = 20; // calcula el área area = radio * radio * 3.14159; // imprime el resultado System.out.println( "El área del círculo es: " + area ); // no confundir la igualdad matemática y la asignación // esto es un error: // 4 + 5 = x; // x + y = y + 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. El tipo de una variable indica la clase de valor que ésta puede almacenar, así como las operaciones que se puede hacer con ella. Para asignar un valor a una variable se usa el operador de asignación, que es el signo igual (=).

11

Aprenda Java Para emplear el valor de las variables basta con hacer referencia al nombre de éstas dentro del código del programa. Para hacer operaciones matemáticas se utilizan los operadores aritméticos (+ - * / %). Una expresión aritmética es un cálculo que produce un valor y está compuesta por operadores aritméticos y operandos. El programa siguiente, DobleNumero.java, utiliza una expresión aritmética para calcular el doble de un número. //Programa que calcula el doble de un número. public class DobleNumero { public static void main(String[] args) { // declaración de la variable // int numero; //error usar una variable sin valor asignado int numero = 5; // asigna un valor a la variable // proceso int doble = numero * 2; // realiza el cálculo // salida System.out.printf("El doble de %d es %d\n", numero, doble); } // 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. No se puede utilizar una variable si no tiene un valor asignado. Intentar utilizar una variable sin un valor asignado genera un error en tiempo de compilación. Los tipos de variables como int o double se conocen como tipos primitivos o tipos integrados. Los nombres de los tipos primitivos son palabras clave y, por lo tanto, deben escribirse en minúsculas. El método printf de System.out utiliza el especificador de formato %d para mostrar un número entero, %f para un número en punto flotante y %s para las cadenas.

2.2. Leer datos desde el teclado. Java proporciona una clase pre-compilada llamada Scanner, que permite obtener entradas desde el teclado. Dado que la clase Scanner no es parte del conjunto fundamental de las clases de Java necesitamos indicarle al compilador donde encontrarla. El programa siguiente, AreaCirculo.java es nos permitir leer datos desde el teclado y calcular el área de un círculo. //Calcula el área de un círculo. import java.util.Scanner; //para leer del teclado

12

Aprenda Java public class AreaCirculo { public static void main(String[] args) { // Crea objeto para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaración de variables double radio; double 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 * 3.14159; // imprime el resultado System.out.printf("El área del círculo es: %f", area); } // fin del método main } // fin de la clase AreaCirculo

Para utilizar la clase Scanner se utiliza la instrucción: import java.util.Scanner;. Se requiere insertar esta instrucción en la parte superior del método main: Scanner entrada = new Scanner(System.in);.

La expresión new Scanner(System.in); crea un objeto y le pasa como argumento el teclado que está representado con System.in. Este objeto almacena los caracteres introducidos desde el teclado. Una vez creado el objeto, se puede leer y almacenar un número con la llamada al método nextDouble para el caso de los números en punto flotante. Para continuar aprendiendo programación con Java, veamos un par de ejemplos que nos permitan trabajar con variables enteras y de punto flotante. En primer lugar vamos a escribir un programa que nos permita leer del teclado dos números enteros, calcular la suma e imprimir el resultado en la consola de salida. //Ejemplo de variables, operadores aritméticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Suma { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in);

13

Aprenda Java

// declaración de variables int numero1; // primer número a sumar int numero2; // segundo número a sumar int suma; // almacena la suma de numero1 + numero2 // mensaje de usuario System.out.println("Programa que suma dos números enteros."); System.out.println("--------------------------------------"); // entrada System.out.print("Primer número a sumar? "); // indicador numero1 = entrada.nextInt(); // lee el primer número System.out.print("Segundo número a sumar? "); // indicador numero2 = entrada.nextInt(); // lee el segundo número // proceso suma = numero1 + numero2; // suma los números // salida System.out.printf("La suma es %d\n", suma); // 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. Java cuenta con un gran conjunto de clases que se organizan en paquetes y se les conoce como la biblioteca de clases de Java o la API de Java. Una vez creado el objeto con Scanner entrada = new Scanner(System.in);, se puede leer y almacenar un número entero con la llamada al método nextInt. Con el programa siguiente, Producto.java, utilizaremos dos variables de tipo float y calcularemos su producto. //Ejemplo de variables, operadores aritméticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Producto { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Programa que multiplica dos números."); System.out.println("------------------------------------"); // entrada System.out.print("Primer número? "); // indicador

14

Aprenda Java float numero1 = entrada.nextFloat(); // lee el primer número System.out.print("Segundo número? "); // indicador float numero2 = entrada.nextFloat(); // lee el segundo número // proceso float producto = numero1 * numero2; // salida System.out.printf("%.2f x %.2f = %.2f\n", numero1, numero2, producto); } // fin del método main } // fin de la clase Producto

El especificador de formato %.2f nos permite indicar el número de decimales a mostrar.

2.3. Identificadores. Un identificador es el término técnico para el nombre de un componente de programa: el nombre de una clase, el nombre de un método, una variable, etc. El programa siguiente, Identificador.java, muestra los identificadores en Java. //Ejemplos de identificadores en Java. public class Identificador { public static void main(String[] args) { float costoTotal; System.out.println("Identificador -> identificador clase"); System.out.println("main -> identificador método"); System.out.println("costoTotal -> identificador variable"); } // fin del metodo main } // fin de la clase Identificador

Los identificadores deben estar formados enteramente por letras, dígitos y caracteres como signos de moneda ($) y/o guión bajo (_). El primer carácter no debe ser un número. Si un identificador no sigue estas reglas, el programa no compilará. Veamos un ejemplo de como no declarar identificadores en Java. El programa siguiente, NoIdentificador.java, muestra como no declarar identificadores en Java. //El programa no funciona solo ilustra identificadores no validos. public class NoIdentificador { public static void main(String[] args) { // float costo Total; //contiene espacios // int 3deseos; //inicia con un número // boolean public; //public es palabra clave

15

Aprenda Java // boolean tengo.Mascota; //contiene un punto // double #numPrimo; //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, es decir hace distinción entre minúsculas y mayúsculas. El programa siguiente, CaseSensitive.java, demuestra lo mencionado anteriormente. //Ejemplo de identificadores case-sensitive. public class CaseSensitive { public static void main(String[] args) { int suma = 5; // variable local int SUMA = 12; // SUMA es distinta de suma // imprime el contenido de la variable System.out.println("El valor de suma es " + suma); System.out.println("El valor de SUMA es " + SUMA); // esto es un error, suma no está definida // System.out.println( "El valor de SUMA es " + Suma ); } // fin del método main } // fin de la clase Suma

2.4. Variables. Una variable en Java puede almacenar sólo un tipo de valor. Por ejemplo, una variable de tipo entero sólo puede almacenar valores enteros y no valores en punto flotante. El programa siguiente, Variable.java, utiliza variables para guardar y manipular datos. //Programa que declara y manipula variables. public class Variable { public static void main(String[] args) { // declaración de variables int edad; double sueldo; // también se pueden declarar en una sola línea // int x, y, z; //usar nombres de variables significativos // no se puede declarar una variable más de una vez // int a, b, c; // int a; //esto es un error // asignación de valores a las variables edad = 18; sueldo = 15400.20;

16

Aprenda Java // declaración e inicialización de una variable int numeroSuerte = 38; // uso del valor de una variable System.out.println(edad); System.out.println(sueldo); System.out.println(numeroSuerte); // asignación incorrecta // edad = 18.50; //los tipos no coinciden // la variable aumento no tiene un tipo // aumento = 1500.0; //error de sintaxis // declaración de una variable int x; // la variable x no tiene un valor inicial // x = x + 1; //error de sintaxis } // fin del método main } // fin de la clase Variable

Los nombres de variables son identificadores. En Java, los números no tienen comas. Java utiliza el signo igual (=) para las instrucciones de asignación. Una instrucción de asignación pone un valor dentro de una variable. Veamos un ejemplo que nos permita practicar con todos los conceptos estudiados hasta el momento. El programa siguiente, Numero234.java, calcula el doble, triple, cuádruple de un número. //Ejemplo de variables, operadores aritméticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Numero234 { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaración de variables int numero, doble, triple, cuadruple; // mensaje de usuario System.out.println( "Calcula el doble, tripe y cuádruple de un número."); System.out.println( "-------------------------------------------------"); // entrada System.out.print("Número? "); // indicador numero = entrada.nextInt(); // lee el número

17

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

Aprenda Java double metros = nPies * PIE_METRO; // salida System.out.printf("%.2f pies son %.2f metros", nPies, metros); } // fin del método main } // fin de la clase PieMetro

2.7. Tipos de datos primitivos. Hay seis tipos de datos numéricos en Java: byte, short, int, long, float y double. Los cuatro primeros se utilizan para almacenar números enteros y los dos últimos para almacenar números en punto flotante. La diferencia entre estos seis tipos de datos numéricos es principalmente el rango de valores que pueden representar. Se dice que un tipo de datos con un rango variable más grande tiene mayor precisión. Por ejemplo el tipo double tiene una precisión mayor que el tipo de datos float. En Java también se utiliza el tipo de dato char así como el boolean. El programa siguiente, TipoPrimitivo.java, muestra los ocho tipos de datos primitivos en Java. //Programa que muestra los ochos tipos de datos primitivos. public class TipoPrimitivo { public static void main(String[] args) { // tipos integrales byte edad = 38; // 8 bits short distancia = 127; // 16 bits int sumaTotal = 1250; // 32 bits -->por default long distanciaLuna = 238857; // 64 bits // punto flotante float salario = 3850.0f; // 32 bits // asignación ilegal // float salario = 3850.00; //3850.00 está en 64 bits double granTotal = 125000.50; // 64 bits -->por default // tipo carácter char letra = 'A'; // 16 bits UNICODE // asignación ilegal // char letra = "A"; //String->comillas dobles // tipo boolean boolean tengoPerro = false; // valores: true/false // cuidado con el overflow // int valor = 2147483647 + 1; //-2147483648

21

Aprenda Java // cuidado con el underflow // int otroValor = -2147483648 - 1; //2147483647 } // fin del método main } // fin de la clase TipoPrimitivo

Los tipos de variables definen un conjunto de valores que pueden tomar las variables. Al asignar a una variable un valor que rebasa sus límites, ocurre un error de desbordamiento. La computadora tiene que representar los números mediante una cantidad fija de unos y ceros. En muchos casos, la computadora puede representar los números con exactitud; pero en otros, la representación del número es sólo cercana, no exacta. El programa siguiente, Precisión.java, muestra lo que sucede con la aproximación de punto flotante. //Ilustra el concepto de precisión. public class Precision { public static void main( String[] args ) { System.out.println( 10 ); //se representa en 32 bits System.out.println( 10.0 ); //se representa en 64 bits System.out.println( 10.0F ); //se representa en 32 bits p.f. System.out.println( 7 / 3 ); //32 bits enteros System.out.println( 7.0 / 3.0 ); //64 bits punto flotante System.out.println( 7.0F / 3 ); //7.0F -> 32 bits p.flotante //imprime 0.89999999999999999 System.out.println( 2.0 - 1.1 ); //error de redondedo System.out.println( 100 * 4.35 ); } //fin del método main } //fin de la clase Precision

2.8. Operadores aritméticos. Los operadores aritméticos pueden utilizarse con los tipos enteros y en punto flotante. Lo que debemos de tener en cuenta es que si los operandos son enteros, el resultado es un entero y si alguno de ellos está en punto flotante, el resultado se expresa en punto flotante. El programa siguiente, CalculadoraSimple.java, muestra los operadores aritméticos en Java. //Calculadora simple en Java. import java.util.Scanner; //para leer del teclado public class CalculadoraSimple { public static void main(String[] args) { // Crea objeto Scanner para obtener la entrada del teclado Scanner entrada = new Scanner(System.in); int numeroUno, numeroDos;

22

Aprenda Java

// mensaje de usuario System.out.println("Calculadora Java."); System.out.println("-----------------"); System.out.print("Escribe el primer número: "); // indicador numeroUno = entrada.nextInt(); System.out.print("Escribe el segundo número: "); // indicador numeroDos = entrada.nextInt(); System.out.printf("La suma es %d\n", numeroUno + numeroDos); System.out.printf("La resta es %d\n", numeroUno - numeroDos); System.out.printf("El producto es %d\n",numeroUno * numeroDos); System.out.printf("La división es %d\n",numeroUno / numeroDos); System.out.printf("El residuo es %d\n", 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. El operador de módulo devuelve el resto de una división. Veamos un par de ejemplos para ilustrar este concepto. El programa siguiente, División.java, demuestra la división de enteros y el operador de módulo. //Programa para calcular la división y módulo de dos números enteros. import java.util.Scanner; //para leer del teclado public class Division { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print( "Introduce un número? " ); int num1 = entrada.nextInt(); System.out.print("Introduce otro número? "); int num2 = entrada.nextInt(); // proceso int div1 = num1 / num2; int mod1 = num1 % num2; int div2 = num2 / num1; int mod2 = num2 % num1; // salida System.out.println(div1); System.out.println(mod1);

23

Aprenda Java System.out.println(div2); System.out.println(mod2); } // fin del método main } // fin de la clase Division

El programa siguiente, SumaDigitos.java, 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. //Programa que suma los dígitos de un número entre 0 y 1000. import java.util.Scanner; //para leer del teclado public class SumaDigitos { public static void main(String[] args) { int unidad, decena, centena; int numero, temporal, suma; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce un número entre 0 y 1000? "); numero = entrada.nextInt(); // proceso temporal = numero; unidad = temporal % 10; temporal = temporal / 10; decena = temporal % 10; temporal = temporal / 10; centena = temporal % 10; suma = unidad + decena + centena; // salida System.out.printf("La suma de los dígitos de %d es %d ", numero, suma); } // fin del método main } // fin de la clase SumaDigitos

2.9. Literales en Java. Una literal es la representación de un valor en el código fuente de un programa. En Java tenemos literales para representar números enteros, en punto flotante, caracteres, booleanos y cadenas. El programa siguiente, Literal.java, demuestra el uso de las literales en Java. //Programa que utiliza literales. public class Literal { public static void main(String[] args) { System.out.println(10); // literal entera 32 bits

24

Aprenda Java System.out.println(10L); // literal entera 64 bits System.out.println(10.0D); // literal en punto flotante 64 bits System.out.println(10.0F); // literal en punto flotante 32 bits System.out.println('A'); // literal char System.out.println(true); // literal boolean System.out.println("A"); // literal String } // fin del método main } // fin de la clase Literal

2.10. La evaluación de expresiones en Java. Cuando una expresión aritmética tiene más de un operador aritmético, el orden de aplicación de los operadores sigue un orden preciso determinado por las reglas jerarquía de los operadores aritméticos. Por ejemplo, las operaciones entre paréntesis se realizan primero en una expresión, y le siguen de izquierda a derecha la multiplicación o división y finalmente la suma y la resta. Veamos algunos ejemplos que nos permitirán practicar con estos conceptos. El programa siguiente, Expresión.java, demuestra la evaluación de expresiones aritméticas en Java. //Expresión aritmética. public class Expresion { public static void main(String[] args) { int resultado = 14 + 8 / 2; // expresión aritmética System.out.println(resultado); resultado = (14 + 8) / 2; System.out.println(resultado); resultado = 14 + (8 / 2); System.out.println(resultado); } // fin del método main } // fin de la clase Expresion

El programa siguiente, Promedio.java, demuestra la evaluación de expresiones aritméticas en Java. //Programa que calcula el promedio de tres calificaciones. public class Promedio { public static void main(String[] args) { // declaración y asignación de los valores double calif1 = 10.0, calif2 = 10.0, calif3 = 10.0; double promedio = 0.0; // es buena práctica inicializar

25

Aprenda Java // mensaje de usuario System.out.println("Promedio de tres calificaciones."); System.out.println("--------------------------------"); promedio = calif1 + calif2 + calif3 / 3; System.out.printf("El promedio incorrecto es: %.2f\n", promedio); promedio = (calif1 + calif2 + calif3) / 3; System.out.printf("El promedio correcto es: %.2f\n", promedio); } // fin del método main } // fin de la clase Promedio

2.11. Operadores abreviados y de incremento/decremento. Java proporciona los operadores de incremento, decremento y asignación compuesta que permiten escribir una expresión aritmética en una forma compacta. Veamos un par de ejemplos. El programa siguiente, OpAbreviado.java que utiliza los operadores abreviados. //Muestra los operadores abreviados. public class OpAbreviado { public static void main(String[] args) { int x = 2; x += 3; // x = x + 3; System.out.println("x = " + x); x -= 3; // x = x – 3; System.out.println("x = " + x); x *= 2; // x = x * 2 System.out.println("x = " + x); x /= 2; // x = x / 2 System.out.println("x = " + x); } // fin del método main } // fin de la clase OpAbreviado

Los operadores abreviados son los siguientes: +=, -=, *=, /= y %= y permiten simplificar la escritura de expresiones en Java. No hay espacios entre los operadores abreviados. Por ejemplo: + = debe escribirse como +=.

26

Aprenda Java El programa siguiente, incremento/decremento.

IncrementoDecremento.java,

utiliza

los

operadores

de

//Operadores de incremento/decremento. public class IncrementoDecremento { public static void main(String[] args) { int x = 0, y = 0; x++; // x = x + 1; x--; // x = x - 1; System.out.println(x); // el valor de x es cero System.out.println("Trabajando con el operador postfijo."); y = x++; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("Trabajando con el operador prefijo."); y = ++x; System.out.println("x = " + x); System.out.println("y = " + y); // // // // // //

a tener en cuenta int i = 10; int num = 10 * i++; es lo mismo que int num = 10 * i; i = i + 1;

// a tener en cuenta // int i = 10; // int num = 10 * (++i); // es lo mismo que // i = i + 1; // int num = 10 * i; } // fin del método main } // fin de la clase IncrementoDecremento

Los operadores ++ y -- se utilizan para incrementar o decrecer un valor en 1. Por ejemplo, x++ incrementa el valor de x en 1, al igual que la expresión x = x + 1. De manera similar x-decrece el valor de x en 1. Estos operadores de incrementos y decrementos se pueden fijar antes o después; es decir, el ++ o -- puede aparecer antes o después del valor que incremente o decrece. Cuando utilizamos el operador de posfijo primero se asigna y luego se incrementa. Con el operador prefijo primero se incrementa la variable y luego se asigna. 27

Aprenda Java

2.12. Conversión de tipo (type casting). Cuando una expresión aritmética está formada por variables y constantes del mismo tipo, el resultado se expresa en ese mismo tipo de dato. Cuando los tipos de datos de las variables y constantes en una expresión aritmética son distintos, es necesario llevar a cabo una conversión. Una conversión de tipo es un proceso que convierte el valor de un tipo de datos a otro tipo de datos. Hay dos conversiones posibles en Java: implícitas y explícitas. Una conversión implícita, denominada promoción numérica, se aplica a todos los operandos de un operador aritmético. Esta conversión se denomina promoción porque el operando se convierte de menor a mayor precisión. 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. El programa siguiente, Conversion.java, ilustra el concepto de conversión de tipo. //Programa que demuestra la conversión de tipos. public class Conversion { public static void main(String[] args) { // conversión implícita System.out.println(3 * 4.5); // es lo mismo que 3.0 * 4.5 // conversión explícita System.out.println((int) 40.7); // se pierde la fracción System.out.println((double) 1 / 2); // 1920 que está en int (32 bits) se convierte // a double (64 bits) double distancia = 1920; // int temp = distancia; //asignación ilegal int aumento = (int) 1520.75; // casting, perdida de precisión System.out.println(distancia); System.out.println(aumento); // elevar un número a la n potencia int cubo = (int) Math.pow(5, 3); // sacar la raíz cuadrada de un número int raiz = (int) Math.sqrt(81); System.out.println(cubo); System.out.println(raiz); } // fin del método main } // fin de la clase Conversion

28

Aprenda Java La clase Math contiene métodos de clase frecuentemente usados en las funciones matemáticas. 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. Véamos otros ejemplos que nos permitan trabajar con los conceptos estudiados anteriormente. El programa siguiente, Sueldo.java, calcula el sueldo de un trabajador. //Ejemplo de variables, operadores aritméticos y la clase Scanner. import java.util.Scanner; // para leer desde el teclado. public class Sueldo { public static void main(String[] args) { // crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in); // declaración de variables float sueldoBase; // sueldo del trabajador float ventas; // ventas realizadas por el trabajador float comision; // la comisión por las ventas realizadas float sueldoTotal; // el sueldo total // mensaje de usuario System.out.println("Calcula el sueldo de un trabajador."); System.out.println("-----------------------------------"); // entrada System.out.print("Sueldo base? "); // indicador sueldoBase = entrada.nextFloat(); // lee el sueldo base System.out.print("Ventas realizadas? "); // indicador ventas = entrada.nextFloat(); // las ventas realizadas // proceso // comision = ventas * 0.10; //perdida de precisión // comision = ventas * 0.10F; //ok comision = (float) (ventas * 0.10); // casting sueldoTotal = sueldoBase + comision; // salida System.out.printf("Sueldo base $%.2f\n", sueldoBase); System.out.printf("Comisión $%.2f\n", comision); System.out.printf("Sueldo total $%.2f\n", sueldoTotal); } // fin del método main } // fin de la clase Sueldo

29

Aprenda Java El programa siguiente, VolumenCilindro.java, calcula el volumen de un cilindro. //Programa que calcula el volumen de un cilindro. import java.util.Scanner; //para leer del teclado public class VolumenCilindro { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Calcula el volumen de un cilindro."); System.out.println("----------------------------------"); // lectura de los datos System.out.print("Radio? "); float radio = entrada.nextFloat(); System.out.print("Altura? "); float altura = entrada.nextFloat(); // proceso de los datos float area = (float) (Math.pow(radio, 2) * Math.PI); float volumen = area * altura; // impresión de los resultados System.out.printf("Área cilindro: %.2f\n", area); System.out.printf("Volumen cilindro: %.2f\n", volumen); } // fin del método main } // fin de la clase VolumenCilindro

El programa siguiente, Hipotenusa.java, calcula la hipotenusa de un triángulo rectángulo. /Programa para calcular la hipotenusa de un triángulo rectángulo. import java.util.Scanner; //para leer del teclado public class Hipotenusa { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Hipotenusa de un triángulo rectángulo."); System.out.println("--------------------------------------"); // lectura de los datos System.out.print("Ingresa los valores para el cateto a y b: "); int catetoA = entrada.nextInt(); int catetoB = entrada.nextInt(); // procesa los datos int hipotenusa = (int) Math.sqrt(Math.pow(catetoA, 2)

30

Aprenda Java + Math.pow(catetoB, 2)); // imprime el resultado System.out.printf("La hipotenusa es: %d", hipotenusa); } // fin del método main } // fin de la clase Hipotenusa

2.13. Ejercicios resueltos. 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, selección, repetición). Este proceso de aprendizaje inicia con el lápiz y papel; 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. Una vez que tenemos la idea de como resolver el problema, lo siguiente es codificar el programa, compilar, corregir los errores de sintaxis y verificar que nuestro programa produce los resultados adecuados. Finalmente, hay que documentar el programa. Para empezar nuestro proceso de aprendizaje con Java, podemos seguir las siguientes etapas: • • • •

Declarar de variables. Entrada/Lectura de los datos. Proceso de cálculo (una o más fórmulas). Salida/Impresión de resultados.

Nota: los problemas que se resuelven aquí no tienen una solución única. Problema 1. Escribir un programa que permita convertir una cantidad dada en metros a sus equivalentes en centímetros, pulgadas, pies y yardas. Considera la siguiente información: 1 metro = 100 centímetros 1 pie = 12 pulgadas 1 yarda = 3 pies 1 pulgada = 2.54 centímetros //Dada una cantidad de metros imprime su equivalencia en otras //unidades de medida. import java.util.Scanner; //para leer del teclado

31

Aprenda Java

public class Metro { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declaración de variables double nMetros, pie, pulgada, yarda, centimetro; System.out.println("Convierte metros a otras medidas."); System.out.println("---------------------------------"); // entrada System.out.println("Cantidad de metros? "); nMetros = entrada.nextDouble(); // proceso de conversión centimetro = nMetros * 100; pulgada = centimetro / 2.54; pie = pulgada / 12; yarda = pie / 3; // salida de resultados System.out.printf("%.2f System.out.printf("%.2f System.out.printf("%.2f System.out.printf("%.2f System.out.printf("%.2f } // fin del método main } // fin de la clase Metro

metros equivalen a:\n\n", nMetros); centímetros\n", centimetro); pulgadas\n", pulgada); pies\n", pie); yardas\n", yarda);

Problema 2. Linus Torvalds, Miguel de Icaza y James Gosling aportan cantidades de dinero para formar una empresa de tecnologías avanzadas. Escribe un programa que determine el capital formado y el porcentaje de dicho capital que aporta cada uno de los inversionistas. //Programa que calcula la proporción de tres cantidades. import java.util.Scanner; //para leer del teclado public class Inversion { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declaración de variables float dineroTorvalds = 0.0f; float dineroIcaza = 0.0f; float dineroGosling = 0.0f;

32

Aprenda Java

// es buena práctica de programación declarar e inicializar float porcentajeTorvalds = 0.0f; float porcentajeIcaza = 0.0f; float porcentajeGosling = 0.0f; float capital = 0.0f; // el total de inversión System.out.println("Capital invertido."); System.out.println("------------------"); // entrada de datos System.out.println("Introduce las tres cantidades:"); System.out.print("Linus Torvalds $"); dineroTorvalds = entrada.nextFloat(); System.out.print("Miguel de Icaza $"); dineroIcaza = entrada.nextFloat(); System.out.print("James Gosling $"); dineroGosling = entrada.nextFloat(); // calcula el el capital formado capital = dineroTorvalds + dineroIcaza + dineroGosling; // determina los porcentajes de cada capital respecto del total porcentajeTorvalds = dineroTorvalds * 100 / capital; porcentajeIcaza = dineroIcaza * 100 / capital; porcentajeGosling = dineroGosling * 100 / capital; // salida de resultados System.out.printf("Total de capital a invertir: $%.2f\n", capital); System.out.printf("Linus Torvalds tiene el %.2f porciento\n", porcentajeTorvalds); System.out.printf("Miguel de Icaza tiene el %.2f porciento\n", porcentajeIcaza); System.out.printf("James Gosling tiene el %.2f porciento\n", porcentajeGosling); } // fin del método main } // fin de la clase Inversion

Problema 3. Se usa una cantidad conocida como índice de masa corporal (IMC)para calcular el riesgo de los problemas de salud relacionados con el peso. El IMC se calcula como la fórmula IMC=

w ( h/100)2

en donde w es el peso en kilogramos y h es la altura en centímetros. Un IMC de 20 a 25 se 33

Aprenda Java considera “normal”. Escribe un programa que acepte el peso y la altura (ambos en números enteros) y produzca el IMC. //Programa que calcula el índice de masa corporal. import java.util.Scanner; //para leer del teclado public class IndiceMasaCorporal { public static void main(String[] args) { int pesoCorporal; // en kilos int altura; // en centímetros double imc; Scanner entrada = new Scanner(System.in); System.out.println("Calcula el índice de masa corporal."); System.out.println("-----------------------------------"); // entrada System.out.print("Introduce el peso(kilos) y altura(cms): "); pesoCorporal = entrada.nextInt(); altura = entrada.nextInt(); // proceso imc = pesoCorporal / Math.pow(altura / 100.0, 2); // salida System.out.printf("El índice de masa corporal es %.2f\n", imc); } // fin del método main } // fin de la clase IndiceMasaCorporal

Problema 4. Escribe un programa que calcule la distancia entre dos puntos P1 y P2 de un plano cartesiano. Para calcular la distancia d entre los dos puntos aplicamos la siguiente fórmula: d= √ (( X 1−X 2 )2+ (Y 1 −Y 2)2 ) //Calcula la distancia entre dos puntos. import java.util.Scanner; //para leer del teclado public class Distancia { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Calcula la distancia entre dos puntos."); System.out.println("--------------------------------------"); // entrada

34

Aprenda Java System.out.print("Introduce el punto (x1,y1): "); double x1 = entrada.nextDouble(); double y1 = entrada.nextDouble(); System.out.print("Introduce el punto (x2,y2): "); double x2 = entrada.nextDouble(); double y2 = entrada.nextDouble(); // proceso double d = Math.sqrt(Math.pow((x1 - x2), 2) + Math.pow((y1 - y2), 2)); // salida System.out.printf( "La distancia entre los dos puntos es %.2f\n", d); } // fin del método main } // fin de la clase Distancia

Problema 5. Su peso es realmente la cantidad de atracción gravitacional ejercida sobre usted por la Tierra. Puesto que la gravedad es únicamente 1/6 de la gravedad que en la Tierra, en la luna usted únicamente debería pesar 1/6 de lo que pesa en la Tierra. Escribe un programa que reciba el peso del usuario en la Tierra y calcule su peso en Mercurio, Venus, Júpiter y Saturno. Use los valores de la tabla de abajo. Planeta

Multiplique el peso en la Tierra por

Mercurio

0.4

Venus

0.9

Júpiter

2.5

Saturno

1.1

//Programa que calcula el peso en otros planetas. import java.util.Scanner; //para leer del teclado public class PesoPlanetas { public static void main(String[] args) { // constantes final double PESO_MERCURIO = 0.4; final double PESO_VENUS = 0.9; final double PESO_JUPITER = 2.5; final double PESO_SATURNO = 1.1; // variables double pesoCorporal;

35

Aprenda Java double pesoMercurio, pesoVenus, pesoJupiter, pesoSaturno; Scanner entrada = new Scanner(System.in); System.out.println("Calcula el peso en otros planetas."); System.out.println("----------------------------------"); // entrada System.out.print("Peso corporal (kgs)? "); pesoCorporal = entrada.nextDouble(); // proceso pesoMercurio = pesoCorporal * PESO_MERCURIO; pesoVenus = pesoCorporal * PESO_VENUS; pesoJupiter = pesoCorporal * PESO_JUPITER; pesoSaturno = pesoCorporal * PESO_SATURNO; // salida System.out.printf("En la Tierra pesas: %.2f kgs.\n", pesoCorporal); System.out.printf("En Mercurio pesas: %.2f kgs.\n", pesoMercurio); System.out.printf("En Venus pesas: %.2f kgs.\n", pesoVenus); System.out.printf("En Júpiter pesas: %.2f kgs.\n", pesoJupiter); System.out.printf("En Saturno pesas: %.2f kgs.\n", pesoSaturno); } // fin del método main } // fin de la clase PesoPlanetas

Problema 6. Cuando usted dice que tiene 18 años, está diciendo realmente que la Tierra ha dado 18 vueltas al Sol. Puesto que a otros planetas les cuesta más o menos días que a la Tierra dar una vuelta alrededor del Sol, su edad sería distinta en otros planetas. Se puede calcular lo viejo que usted sería en otros planetas mediante la fórmula: y = (x * 365) /d, donde x es la edad de la Tierra, y es la edad en otro planeta, y d es el número de días de la Tierra que el planeta y viaja alrededor del Sol. Escribe una aplicación que reciba como entrada la edad del usuario en la Tierra e imprima su edad en Mercurio, Venus, Júpiter y Saturno. Los valores para d en esos planetas se dan en la tabla siguiente:

36

Aprenda Java Planeta

d = número aproximado de días

Mercurio

88

Venus

225

Júpiter

4380

Saturno

10767

//Programa que calcula la edad en otros planetas. import java.util.Scanner; //leer del teclado public class EdadPlanetas { public static void main(String[] args) { // constantes final int DIAS_MERCURIO = 88; final int DIAS_VENUS = 225; final int DIAS_JUPITER = 4380; final int DIAS_SATURNO = 10767; final int DIAS_AÑO = 365; // variables int edad, diasTerrestres; int edadMercurio, edadVenus, edadJupiter, edadSaturno; Scanner entrada = new Scanner(System.in); System.out.println("Calcula la edad en otros planetas."); System.out.println("----------------------------------"); // entrada System.out.print("Edad? "); edad = entrada.nextInt(); // proceso diasTerrestres = edad * DIAS_AÑO; edadMercurio = diasTerrestres / DIAS_MERCURIO; edadVenus = diasTerrestres / DIAS_VENUS; edadJupiter = diasTerrestres / DIAS_JUPITER; edadSaturno = diasTerrestres / DIAS_SATURNO; // salida System.out.printf("Edad System.out.printf("Edad System.out.printf("Edad System.out.printf("Edad System.out.printf("Edad } // fin del método main } // fin de la clase EdadPlanetas

en en en en en

la Tierra: %d\n", edad); Mercurio: %d\n", edadMercurio); Venus: %d\n", edadVenus); Júpiter: %d\n", edadJupiter); Saturno: %d\n", edadSaturno);

37

Aprenda Java Problema 7. El programa siguiente, HoraSegundos.java, convierte horas, minutos y segundos a segundos. //Programa que lee una hora, minutos y segundos y calcula //la cantidad de segundos equivalente. import java.util.Scanner; //para leer del teclado public class HoraSegundos { public static void main(String[] args) { // constantes final int HORA_SEG = 3600; final int MIN_SEG = 60; // variables int hora, minuto, segundo; int nSegundos; Scanner entrada = new Scanner(System.in); System.out.println("Convierte hora-min-seg a segundos."); System.out.println("----------------------------------"); // lectura System.out.print( "Introduce una hora, mins y segs (ejemplo 1 28 42): "); hora = entrada.nextInt(); minuto = entrada.nextInt(); segundo = entrada.nextInt(); // proceso nSegundos = hora * HORA_SEG + minuto * MIN_SEG + segundo; // salida System.out.printf( "Una %d hora(s), %d min(s), %d seg(s) son %d segundos\n", hora, minuto, segundo, nSegundos); } // fin del método main } // fin de la clase HoraSegundos

38

Aprenda Java Problema 8. Escribe un programa que lea un número entero de cinco cifras y determine la cifra central del número. Así, si el número ingresado fuera 45781, la cifra central a mostrar es 7. //Obtiene la cifra central de un número de cinco cifras import java.util.Scanner; //para leer del teclado public class CifraCentral { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int digitoCentral = 0; // entrada System.out.print("Número de cinco cifras?"); numero = entrada.nextInt(); // determina la cifra central digitoCentral = (numero % 1000) / 100; // salida de resultados System.out.printf("La cifra central es %d", digitoCentral); } // fin del método main } // fin de la clase CifraCentral

Problema 9. Se pide un préstamo de P pesos durante n años a una tasa de interés i. Al final de n años, el importe de la deuda es de P(i+i) n pesos. Escribe un programa para leer P, i (en porcentaje), n y además, para calcular el importe final del adeudo. Comprueba el programa para P = 100.00, i = 8% y n = 5. //Programa que calcula el adeudo final de un préstamo. import java.util.Scanner; //para leer del teclado public class Prestamo { public static void main(String[] args) { double cantidad, tasaInteres, nAños; double adeudo; Scanner entrada = new Scanner(System.in); System.out.println("Calcula el monto de un préstamo."); System.out.println("--------------------------------"); // entrada

39

Aprenda Java System.out.print("Cantidad solicitada? $"); cantidad = entrada.nextDouble(); System.out.print("Tasa de interés (5,10,20,...)% ? "); tasaInteres = entrada.nextDouble(); System.out.print("A pagar en (1,2,3...) años? "); nAños = entrada.nextDouble(); // proceso adeudo = cantidad * Math.pow(1 + tasaInteres / 100.0, nAños); // salida System.out.printf("El monto final a pagar es de $%.2f", adeudo); } // fin del método main } // fin de la clase Prestamo

Problema 10. Elabora un programa para calcular las monedas que deben darse como cambio en los siguientes casos: • • • •

Si todas las compras fueran menores de un peso. Si el comprador pagara siempre con un billete de a peso. Si debiéramos dar en cambio el número mínimo de monedas. Si solamente podemos dar en cambio monedas de un centavo, de cinco, de diez, de veinte, y de cincuenta.

Verifica el programa para las siguientes compras: 97, 78, 54, 21 y 1 centavos. //Calcula el número mínimo de monedas que deben darse como cambio. import java.util.Scanner; //para leer del teclado public class Monedas { public static void main(String[] args) { final int BILLETE_PESO = 100; // 100 centavos int montoCompra, cambio, temporal; int moneda50, moneda20, moneda10, moneda5, moneda1; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Monto de la compra (menor a 1 peso)? $"); montoCompra = entrada.nextInt(); // proceso cambio = BILLETE_PESO - montoCompra; temporal = cambio;

40

Aprenda Java

moneda50 = temporal / 50; temporal = temporal % 50; moneda20 = temporal / 20; temporal = temporal % 20; moneda10 = temporal / 10; temporal = temporal % 10; moneda5 = temporal / 5; moneda1 = temporal % 5; // salida System.out.printf("Cambio = $%d\n", cambio); System.out.printf("%d monedas de 50 centavos\n", moneda50); System.out.printf("%d monedas de 20 centavos\n", moneda20); System.out.printf("%d monedas de 10 centavos\n", moneda10); System.out.printf("%d monedas de 5 centavos\n", moneda5); System.out.printf("%d monedas de 1 centavos\n", moneda1); } // fin del método main } // fin de la clase Monedas

41

Aprenda Java

3. Instrucciones de selección. Al finalizar esta lección, serás capaz de: •

Escribir programas que involucren instrucciones de selección.

3.1. Tipo de dato boolean. Las variables boolean sólo pueden guardar valores true o false que son palabras clave. Las variables booleanas se utilizan en programación para mantener el registro del estado de cierta acción. El programa siguiente, TipoBoolean.java, declara dos variables booleanas. //Declara variables de tipo boolean. public class TipoBoolean { public static void main(String[] args) { // variables locales boolean tengoMascota = true; boolean tengoDinero = false; // imprime el contenido de la variable System.out.printf("Tengo mascota? %b\n", tengoMascota); System.out.printf("Tengo dinero? %b\n", tengoDinero); } // fin del metodo main } // fin de la clase TipoBoolean

3.2. Operadores relacionales y de igualdad. Los operadores relacionales y de igualdad nos permiten determinar si un valor es igual a, mayor que o menor que otro valor. Cuando los programas utilizan operadores relacionales y de igualdad para comparar valores, el resultado de la comparación es verdadero (true) o falso (false). Veamos como escribir un programa con operadores relacionales y de igualdad. El programa siguiente, ExpresionRelacional.java, utiliza operadores relacionales y de igualdad. //Operadores de igualdad y relacionales. public class ExpresionRelacional { public static void main(String[] args) { System.out.println("10 > 3 es " + (10 > 3)); System.out.println("10 < 3 es " + (10 < 3)); System.out.println("10 >= 3 es " + (10 >= 3)); System.out.println("10 <= 3 es " + (10 <= 3)); System.out.println("10 == 3 es " + (10 == 3)); System.out.println("10 != 3 es " + (10 != 3));

42

Aprenda Java

// esto es un error // boolean x = 10 > = 3; //hay un espacio entre > y = // boolean w = 10 =! 3; //el ! y el = están volteados // int num1 = 5; // int num2 = 6; // esto es un error si lo que se quiere es comparar // boolean z = ( num1 = num2 ); } // fin del método main } // fin de la clase ExpresionRelacional

3.3. La instrucción if simple. La instrucción if simple evalúa una condición utilizando una expresión relacional. Si la condición es verdadera se ejecuta una instrucción o un conjunto de instrucciones que estén definidas en un bloque. En caso que la condición sea falsa, se continúa con la siguiente instrucción del programa. El programa siguiente, Edad.java, demuestra el uso de un if simple. //Demuestra el uso de la instrucción if simple. import java.util.Scanner; //para leer del teclado. public class Edad { public static void main(String[] args) { final int MENOR_EDAD = 18; // declara una constante Scanner entrada = new Scanner(System.in); System.out.print("Ingresa tu edad: "); // indicador int edad = entrada.nextInt(); // lee la edad del usuario System.out.printf("Tienes : %d años.%n", edad); if (edad < MENOR_EDAD) System.out.println( "Por lo tanto todavía no eres un adulto."); System.out.println("La edad es un estado mental."); // también se puede escribir con más claridad con bloques // if (edad < MENOR_EDAD) { // System.out.println( // "Por lo tanto todavía no eres un adulto."); // } //fin if // System.out.println("La edad es un estado mental."); } // fin del método main } // fin de la clase Edad

43

Aprenda Java Las llaves del bloque {...} son opcionales para el caso de los bloques que tienen una instrucción condicional. Utilizamos un if simple cuando queremos hacer una cosa o no hacer nada. El programa siguiente, NumerosIguales.java, utiliza un if simple para determinar si dos 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); } // fin del método main } // fin de la clase NumerosIguales

Podemos utilizar en un programa las instrucciones if que sean necesarias. El programa siguiente, Multiplo.java, utiliza un if simple para determinar si un número es múltiplo de cinco y otro para determinar si ese número es par. //Programa que muestra la estructura de un if simple. import java.util.Scanner; //para leer del teclado public class Multiplo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // lee un número System.out.print("Ingresa un número entero: "); int numero = entrada.nextInt(); if (numero % 5 == 0) { System.out.printf("%d es múltiplo de 5.\n", numero); } // fin if if (numero % 2 == 0) { System.out.printf("%d es par.\n", numero); } // fin if } // fin del método main

44

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, Suma.java, genera dos números aleatorios y permite practicar sumas aritméticas simples. //Programa para practicar sumas. import java.util.Scanner; //para leer del teclado public class Suma { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 10); int numero2 = (int) (Math.random() * 10); // muestra la pregunta al usuario System.out.printf("Cuanto es %d + %d ? ", numero1, numero2); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 + numero2 == respuesta) { System.out.println("La respuesta es correcta."); } // fin if else { System.out.println("La respuesta es incorrecta."); } // fin else } // fin del 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.0, 1.0). En el programa anterior lo multiplicamos por 10 y le hacemos un casting para eliminar la parte fraccionaria y así obtener un número entre 0 y 9. El programa siguiente, Resta.java, es similar al programa anterior, solamente que utiliza un if simple para determinar si un número es mayor que otro, esto es, para no permitir que genera una pregunta con una resta que de un resultado negativo. //Programa para practicar restas. import java.util.Scanner; //para leer del teclado public class Resta { public static void main(String[] args) { // genera los números aleatorios int numero1 = (int) (Math.random() * 10); int numero2 = (int) (Math.random() * 10); // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1; // variable local a if

48

Aprenda Java numero1 = numero2; numero2 = temp; } // fin if // pregunta al usuario System.out.printf("Cuanto es %d - %d ? ", numero1, numero2); // lee la respuesta Scanner entrada = new Scanner(System.in); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 - numero2 == respuesta) System.out.println("La respuesta es correcta."); else System.out.println("La respuesta es incorrecta."); } // fin del método main } // fin de la clase Resta

3.5. Instrucciones if anidadas. Un programa puede evaluar varios casos colocando instrucciones if/else dentro de otras instrucciones if/else, para crear instrucciones if/else anidadas. //Programa que determina si un número se encuentra entre 100 y 200. import java.util.Scanner; //para leer del teclado public class Limites { public static void main(String[] args) { final int LSUP = 200; final int LINF = 100; int numero; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Número? "); numero = entrada.nextInt(); // proceso y salida if (numero >= LINF) if (numero <= LSUP) System.out.printf( "%d se encuentra entre [%d-%d]\n", numero, LINF, LSUP); else System.out.printf(

49

Aprenda Java "%d supera el límite superior.\n", numero); else

System.out.printf( "%d no alcanza el límite inferior.\n", numero); } // fin del método main } // fin de la clase Limites

En una instrucción if anidada, cada instrucción else debe concordar con la instrucción if precedente más próxima. Utilizar demasiadas instrucciones if anidadas hace que los programas se vuelvan más complejos. Estudiemos otros ejemplos. El programa siguiente, PositivoNegativoNulo.java, determina si un número es positivo, negativo o nulo, utilizando instrucciones if anidadas. //Programa que determina si un número es positivo, negativo o nulo. import java.util.Scanner; //para leer del teclado. public class PositivoNegativoNulo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Introduce un número entero: "); int numero = entrada.nextInt(); if (numero > 0) { System.out.println("El número es positivo."); } // fin if else { if (numero == 0) System.out.println("El número es cero."); else System.out.println("El número es negativo."); } // fin else } // fin del método main } // fin de la clase PositivoNegativoNulo

Observa que en programa anterior, utilizamos los bloques {...} para que el programa sea mucho más legible. De otra manera, tendríamos que leer con cuidado el código para determinar a que instrucción if pertenece cada parte else.

50

Aprenda Java El programa siguiente, Divisor.java, utiliza if anidados para determinar si un número es divisor de otro. //Programa que determina si un número es divisor de otro. import java.util.Scanner; //para leer del teclado public class Divisor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce dos números: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); // ¿num2 puede ser divisor? if (num1 > num2) { if (num1 % num2 == 0) System.out.printf( "%d es divisor de %d\n", num2, num1); else // este else se asocia al if más cercano System.out.printf( "%d no es divisor de %d\n", num2, num1); } // fin if else System.out.printf("%d no es divisor de %d\n", num2, num1); } // fin del método main } // fin de la clase Divisor

El programa siguiente, Adivinanza.java, utiliza if anidados para simular un juego de adivinanza, donde el usuario tiene que adivinar un número que se encuentra dentro de un rango de 0 a 9. //Programa para jugar adivinanzas. import java.util.Scanner; //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numeroSecreto = (int) (Math.random() * 10); System.out.print("Piensa un número entre 0 y 9: "); int numero = entrada.nextInt(); if (numero == numeroSecreto) { System.out.println("¡Adivinaste!"); } // fin if else { if (numero < numeroSecreto) {

51

Aprenda Java System.out.println("¡Frío!"); } // fin if else { System.out.println("¡Caliente!"); } // fin else } // fin else } // fin del método main } // fin de la clase Adivinanza

3.6. La instrucción if/else/if. Cuando en una condición existen diversas posibilidades, nos vemos obligados a programar usando if anidados, lo que complica la realización y depuración del código. Para facilitar la programación en estas situaciones se proporciona la instrucción if/else/if. El programa siguiente, DiaSemana.java, lee un número del 1 al 7 y determina el día de la semana utilizando esta técnica. //Programa que dado un número del 1 al 7 determina el día de la semana. import java.util.Scanner; //para leer del teclado public class DiaSemana { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // solicita el día de la semana System.out.print("Introduce un día de la semana (1-7)? "); int dia = entrada.nextInt(); // procesa dependiendo del día if (dia == 1) System.out.println("El día else if (dia == 2) System.out.println("El día else if (dia == 3) System.out.println("El día else if (dia == 4) System.out.println("El día else if (dia == 5) System.out.println("El día else if (dia == 6) System.out.println("El día else if (dia == 7) System.out.println("El día else System.out.println("Número } // fin del método main } // fin de la clase DiaSemana

52

es: Lunes."); es: Martes."); es: Miércoles."); es: Jueves."); es: Viernes."); es: Sábado."); es: Domingo."); de día incorrecto.");

Aprenda Java El programa para jugar a la adivinanza, Adivinanza.java, se puede reescribir utilizando instrucciones if/else/if, lo que simplifica su programación y posible depuración cuando se le tengan que hacer cambios. //Programa para jugar adivinanzas. import java.util.Scanner; //para leer del teclado public class Adivinanza { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numeroSecreto = (int) (Math.random() * 10); System.out.print("Piensa un número entre 0 y 9: "); int numero = entrada.nextInt(); if (numero == numeroSecreto) System.out.println("¡Adivinaste!"); else if (numero < numeroSecreto) System.out.println("¡Frío!"); else System.out.println("¡Caliente!"); } // fin del método main } // fin de la clase Adivinanza

Veamos otros ejemplos. El programa siguiente, Sueldo.java, calcula el salario de un trabajador utilizando instrucciones if/else/if. //Calcula el aumento de sueldo de un trabajador. import java.util.Scanner; //para leer del teclado public class Sueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print("Sueldo trabajador? "); double sueldo = entrada.nextDouble(); // proceso if (sueldo < 1000) sueldo *= 1.25; // sueldo = sueldo * 1.25; else if (sueldo <= 1500) sueldo *= 1.21; // sueldo = sueldo * 1.21; else sueldo *= 1.18; // sueldo = sueldo * 1.18; // salida

53

Aprenda Java System.out.printf("El sueldo del trabajador es $%.2f\n", sueldo); } // fin del método main } // fin de la clase Sueldo

El programa siguiente, ClasificarNumero.java, utiliza instrucciones if/else/if para clasificar un número entero. //Clasifica un número de acuerdo a una categoría. import java.util.Scanner; //para leer del teclado public class ClasificarNumero { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Número? "); // indicador int numero = entrada.nextInt(); if (numero < 0) System.out.printf("%d es menor que cero", numero); else if (numero <= 100) System.out.printf("%d se encuentra entre [0,100]", numero); else System.out.printf("%d es mayor que 100", numero); } // fin del método main } // fin de la clase ClasificarNumero

3.7. Operadores lógicos. Las condiciones simples se expresan en términos de los operadores relacionales >, <, >= y <=, y los operadores de igualdad == y !=; cada expresión evalúa sólo una condición. Para evaluar condiciones múltiples en el proceso de tomar una decisión, ejecutamos estas pruebas en instrucciones separadas o en instrucciones if o if/else anidadas. En ocasiones, las instrucciones if requieren condiciones más complejas para determinar el flujo de control de un programa. Java cuenta con los operadores lógicos, que nos permite formar condiciones más complejas, al combinar las expresiones simples. A continuación estudiaremos el AND condicional (&&), el OR condicional (||) y el NOT lógico (!).

54

Aprenda Java El programa siguiente, OperadoresLogicos.java, demuestra el uso de los operadores lógicos AND, OR y NOT. //Programa que utiliza los operadores lógicos AND, OR y NOT. public class OperadoresLogicos { public static void main(String[] args) { boolean a = true; boolean b = false;

}

//Determina el valor de las variables booleanas System.out.println( a && b ); //false System.out.println( a && true ); //true System.out.println( a || b ); //true System.out.println( b || false ); //false System.out.println( !a ); //false System.out.println( !b ); //true } //fin del método main //fin de la clase OperadoresLogicos

El AND condicional se utiliza cuando queremos verificar que dos condiciones sean verdaderas. El OR condicional se utiliza cuando queremos verificar que al menos una de las condiciones sea verdadera. Y el NOT se usa para negar una condición. El programa siguiente, Adolescente.java, determina si una persona es todavía un adolescente utilizando para ello el AND condicional. //Programa que determina si una persona es un adolescente o no. import java.util.Scanner; //para leer del teclado public class Adolescente { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Edad? "); int edad = entrada.nextInt(); if (edad >= 13 && edad <= 18) System.out.println("Eres un adolescente."); else System.out.println("No eres un adolescente."); // esto es un error // 13 >= edad <= 18 //no funciona igual que en matemáticas } // fin del método main } // fin de la clase Adolescente

55

Aprenda Java El programa siguiente, PromedioPracticas.java, calcula el promedio de cuatro prácticas eliminando la menor. //Determina el promedio de prácticas de un estudiante. import java.util.Scanner; //para leer del teclado public class PromedioPracticas { public static void main(String[] args) { // variables locales int nota1, nota2, nota3, nota4; int suma = 0; float promedio = 0.0F; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce las 4 calificaciones: "); nota1 = entrada.nextInt(); nota2 = entrada.nextInt(); nota3 = entrada.nextInt(); nota4 = entrada.nextInt(); // proceso if (nota1 < nota2 && nota1 < nota3 && nota1 suma = nota2 + nota3 + nota4; else if (nota2 < nota1 && nota2 < nota3 && suma = nota1 + nota3 + nota4; else if (nota3 < nota1 && nota3 < nota2 && suma = nota1 + nota2 + nota4; else if (nota4 < nota1 && nota4 < nota2 && suma = nota1 + nota2 + nota3;

< nota4) nota2 < nota4) nota3 < nota4) nota4 < nota3)

promedio = suma / 3.0F; // obtiene el promedio // salida System.out.printf("El promedio es: %d\n", promedio); } // fin del método main } // fin de la clase PromedioPracticas

El programa siguiente, Loteria.java, 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. //Programa para jugar a la lotería. import java.util.Scanner; //para leer del teclado public class Loteria { public static void main(String[] args) {

56

Aprenda Java // genera el número de la loteria int loto = (int) (Math.random() * 100); Scanner entrada = new Scanner(System.in); System.out.print("Ingresa un número de dos dígitos: "); int numGanador = entrada.nextInt(); // obtiene los dígitos de la lotería int digitoLoto1 = loto / 10; int digitoLoto2 = loto % 10; // obtiene los dígitos del usuario int digito1 = numGanador / 10; int digito2 = numGanador % 10; System.out.printf("El número de la lotería es: %d\n", loto); // Revisa por los premios if (loto == numGanador) System.out.println("Ganaste $10,000.00"); else if (digito2 == digitoLoto1 && digito1 == digitoLoto2) System.out.println("Ganaste $3,000.00"); else if (digito1 == digitoLoto1 || digito1 == digitoLoto2 || digito2 == digitoLoto1 || digito2 == digitoLoto2) System.out.println("Ganaste $1,000.00"); else System.out.println("Sigue participando."); } // fin del método main } // fin de la clase Loteria

El programa siguiente, Apuesta.java, 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.random. //Determina las ganancias al tratar de adivinar los tiros de un dado. public class Apuesta { public static void main(String[] args) { // simula tres tiros de un dado int dado1 = (int) (Math.random() * 6 + 1); int dado2 = (int) (Math.random() * 6 + 1); int dado3 = (int) (Math.random() * 6 + 1); System.out.printf("Dados: %d, %d, %d\n", dado1, dado2, dado3); // determina la ganancia int ganancia = 0;

57

Aprenda Java

if (dado1 == 6 && dado2 == 6 && dado3 == 6) ganancia = 20; else if (dado1 == dado2 && dado1 == dado3 && dado2 == dado3) ganancia = 10; else if (dado1 == dado2 || dado1 == dado3 || dado2 == dado3) ganancia = 5; else System.out.println("Sigue participando"); System.out.println("Tu ganancia es de $" + ganancia); } // fin del método main } // fin de la clase Apuesta

3.8. El operador condicional (?:). Java cuenta con el operador condicional (?:), que en ocasiones puede utilizarse en lugar de una instrucción if/else. Éste es el único operador ternario en Java; es decir, que utiliza tres operandos. En conjunto, los operandos y el símbolo ?: forman una expresión condicional. El primer operando (a la izquierda del ?) es una expresión booleana (es decir, una condición que se evalúa a un valor booleano true o false), el segundo operando (entre el ? y :) es el valor de la expresión condicional si la expresión booleana es verdadera, 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. El programa siguiente, Mayor.java, utiliza el operador condicional para determinar si un número es mayor que otro. //Programa que determina el mayor de dos números. import java.util.Scanner; //para leer del teclado public class Mayor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce dos números: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); int max = (num1 > num2) ? num1 : num2; System.out.println("El mayor es " + max); // equivalente a // if( num1 > num2 ) // System.out.println( "El mayor es " + num1 ); // else // System.out.println( "El mayor es " + num2 ); } // fin del método main } // fin de la clase Mayor

58

Aprenda Java El programa siguiente, ParImpar.java, utiliza el operador condicional para determinar si un número es par/impar. //Programa que determina si un número es par o impar. import java.util.Scanner; //para leer del teclado public class ParImpar { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce un número: "); int num = entrada.nextInt(); System.out.println((num % 2 == 0) ? "Es par." : "Es impar."); } // fin del método main } // fin de la clase ParImpar

3.9. La instrucción switch. La instrucción switch es otra manera de implementar muchas instrucciones if. El programa siguiente, FabricanteDVD.java, utiliza la instrucción switch para determinar la categoría de un determinado fabricante. //Programa que lee un código y determina el fabricante. import java.util.Scanner; public class FabricanteDVD { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print("Código del fabricante (1-4)? "); int codigo = entrada.nextInt(); // proceso y salida switch (codigo) { case 1: System.out.println("3M Corporation"); break; case 2: System.out.println("Maxwell Corporation"); break; case 3: System.out.println("Sony Corporation"); break; case 4: System.out.println("Verbatim Corporation"); break;

59

Aprenda Java default: System.out.println("Código incorrecto"); } // 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, ya que selecciona una de varias acciones distintas o grupo de acciones. La palabra break significa ir al final de la instrucción switch. Estudiemos otros ejemplos. El programa siguiente, AumentoSueldo.java, calcula el aumento de un trabajador utilizando una instrucción switch (aunque es factible utilizar una instrucción if/else/if). //Calcula el aumento de sueldo de un trabajador. import java.util.Scanner; //para leer del teclado public class AumentoSueldo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // entrada System.out.print("Categoría y sueldo del trabajador: "); int categoria = entrada.nextInt(); float sueldo = entrada.nextFloat(); // proceso float nuevoSueldo = 0.0F; switch (categoria) { case 1: nuevoSueldo = sueldo * 1.15F; break; case 2: nuevoSueldo = sueldo * 1.10F; break; case 3: nuevoSueldo = sueldo * 1.08F; break; case 4: nuevoSueldo = sueldo * 1.07F; break; default: System.out.println("Categoría inválida"); } // fin switch // salida

60

Aprenda Java System.out.printf("El nuevo sueldo es $%.2f\n", nuevoSueldo); } // fin del método main } // fin de la clase AumentoSueldo

El programa siguiente, PiedraPapelTijera.java, implementa el juego: piedra-papel-tijera. En este programa se utilizan todos los conceptos estudiados hasta el momento. //Programa para jugar al piedra-papel-tijera. import java.util.Scanner; public class PiedraPapelTijera { public static void main(String[] args) { final int PIEDRA = 1, PAPEL = 2, TIJERA = 3; int jugador, computadora; Scanner entrada = new Scanner(System.in); // solicita la jugada del usuario System.out.print( "Tu jugada? 1 = Piedra, 2 = Papel, 3 = Tijera"); jugador = entrada.nextInt(); // genera la jugada de la computadora computadora = (int) (Math.random() * 3 + 1); // muestra la jugada del usuario System.out.print("La jugada del usuario: "); switch (jugador) { case PIEDRA: System.out.println("PIEDRA"); break; case PAPEL: System.out.println("PAPEL"); break; case TIJERA: System.out.println("TIJERA"); break; } // fin switch // muestra la jugada de la computadora System.out.print("La jugada de la computadora: "); switch (computadora) { case PIEDRA: System.out.println("PIEDRA"); break; case PAPEL: System.out.println("PAPEL"); break; case TIJERA:

61

Aprenda Java System.out.println("TIJERA"); break; } // fin switch // determina el ganador if (jugador == PIEDRA && computadora == PIEDRA) System.out.println("Empate."); else if (jugador == PIEDRA && computadora == PAPEL) System.out.println("La computadora gana."); else if (jugador == PIEDRA && computadora == TIJERA) System.out.println("¡El jugador gana!"); if (jugador == PAPEL && computadora == PIEDRA) System.out.println("¡El jugador gana!"); else if (jugador == PAPEL && computadora == PAPEL) System.out.println("Empate."); else if (jugador == PAPEL && computadora == TIJERA) System.out.println("La computadora gana."); if (jugador == TIJERA && computadora == PIEDRA) System.out.println("La computadora gana."); else if (jugador == TIJERA && computadora == PAPEL) System.out.println("¡El jugador gana!"); else if (jugador == TIJERA && computadora == TIJERA) System.out.println("Empate"); } // fin del método main } // fin de la clase PiedraPapelTijera

3.10. Ejercicios resueltos. En la lección anterior escribimos programas con instrucciones que se ejecutaban en un orden secuencial. A continuación vamos a resolver una serie de ejercicios que nos permitirán afianzar los conceptos de programación hasta ahora estudiados. Nota: los problemas que se resuelven aquí no tienen una solución única. Problema 1. Una tienda de abarrotes vende paletas de dulce a precios unitarios que dependen de la cantidad de unidades adquiridas de acuerdo a la siguiente tabla: Paletas

Precio unitario.

1 a 25

$17.50

26 a 50

$15.00

62

Aprenda Java 51 a 75

$12.50

76 en adelante

$10.00

Adicionalmente, si el cliente adquiere más de 50 paletas la tienda de abarrotes le descuenta el 15% del importe de la compra; en caso contrario, sólo le descuenta el 5%. Escribe un programa que determine el importe de la compra, el importe del descuento y el importe a pagar por la compra de cierta cantidad de paletas de dulce. //Determina lo que hay que pagar por una compra de paletas. import java.util.Scanner; //para leer del teclado public class VentaPaletas { public static void main(String[] args) { // variables locales int numPaletas = 0; double importeCompra = 0.0; double importeDescuento = 0.0; double importePagar = 0.0; Scanner entrada = new Scanner(System.in); System.out.println("Venta de paletas de dulce."); System.out.println("--------------------------"); // entrada System.out.print("Número de paletas a comprar? "); numPaletas = entrada.nextInt(); // cálculo del importe de la compra if (numPaletas >= 1 && numPaletas <= 25) importeCompra = numPaletas * 17.50; if (numPaletas >= 26 && numPaletas <= 50) importeCompra = numPaletas * 15.0; if (numPaletas >= 51 && numPaletas <= 75) importeCompra = numPaletas * 12.50; if (numPaletas >= 76) importeCompra = numPaletas * 10.0; // cálculo del importe del descuento if (numPaletas > 50) importeDescuento = 0.15 * importeCompra; if (numPaletas <= 50) importeDescuento = 0.05 * importeCompra; // calcula el importe a pagar importePagar = importeCompra - importeDescuento;

63

Aprenda Java

// salida de resultados System.out.printf("\nPaletas compradas: %d\n", numPaletas); System.out.printf("Importe de compra: $%.2f\n", importeCompra); System.out.printf("Descuento: $%.2f\n", importeDescuento); System.out.printf("Total a pagar: $%.2f\n", importePagar); } // fin del método main } // fin de la clase VentaPaletas

Problema 2. El promedio final del curso de programación Java se obtiene en base al promedio simple de tres prácticas de laboratorio calificadas. Para ayudar a los alumnos, 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. Diseña y codifica un programa que determine el promedio final de un alumno conociendo sus tres notas. Considera que las calificaciones están en un rango de 1 a 10. //Calcula el promedio de tres notas de laboratorio. import java.util.Scanner; //para leer del teclado public class PromedioFinal { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declara e inicializa las variables double nota1 = 0.0; double nota2 = 0.0; double nota3 = 0.0; double promedio = 0.0; System.out.println("Promedio final del curso Java."); System.out.println("------------------------------"); // entrada System.out.print("Introduce las 3 calificaciones (1-10)? "); nota1 = entrada.nextDouble(); nota2 = entrada.nextDouble(); nota3 = entrada.nextDouble(); // determina si se aumentan dos puntos if (nota3 < 10) { nota3 += 2; if (nota3 > 10) // la calif máxima es 10 nota3 = 10; } // fin if

64

Aprenda Java

// determina el promedio promedio = (nota1 + nota2 + nota3) / 3.0; // salida de resultados System.out.printf("El promedio final es de %.2f\n", promedio); // determina si esta aprobado/reprobado if (promedio > 6) System.out.println("La calificación es aprobatoria"); else System.out.println("La calificación no es aprobatoria"); } // fin del método main } // fin de la clase PromedioFinal

Problema 3. Escribe un programa de manera que la salida sea el resultado de restar el número mayor del menor. Así por ejemplo si los números son 6 y 9 la salida será 3, pero si es 8 y 3, la salida debe ser 5. //Programa que resta el número menor del mayor. import java.util.Scanner; //para leer del teclado public class RestaMenor { public static void main(String[] args) { int numeroUno; int numeroDos; int resta; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Introduce dos números enteros: "); numeroUno = entrada.nextInt(); numeroDos = entrada.nextInt(); // proceso if (numeroUno > numeroDos) resta = numeroUno - numeroDos; else resta = numeroDos - numeroUno; // salida System.out.printf("La resta es %d", resta); } // fin del método main } // fin de la clase RestaMenor

65

Aprenda Java Problema 4. Un programador Java recibe $40 dolares por hora si trabaja semanalmente 40 horas o menos. Si trabaja más de 40 horas se le pagan $40 dolares las primeras 40 horas, y $60 po cada hora adicional. Así, un programador que trabaja 40 horas recibe $1600, mientras que el que trabaja 42 horas recibe 1600 + ( 42 – 40 ) * 60, que da un total de $1720. Escribe un programa que lea el número de horas trabajadas por un programador e imprima el salario a devengar. //Calcula el salario de un programador. import java.util.Scanner; //para leer del teclado public class SalarioProgramador { public static void main(String[] args) { final int HORAS_BASE = 40; final int HORAS_EXTRA = 60; final int SALARIO_SEMANA = 1600; int nHoras, sueldoTotal; Scanner entrada = new Scanner(System.in); // entrada System.out.print("Horas trabajadas? "); nHoras = entrada.nextInt(); // proceso if (nHoras <= HORAS_BASE) sueldoTotal = nHoras * HORAS_BASE; else sueldoTotal = SALARIO_SEMANA + (nHoras - HORAS_BASE) * HORAS_EXTRA; // salida System.out.printf("El salario del trabajador es $%.2f", sueldoTotal); } // fin del método main } // fin de la clase SalarioProgramador

Problema 5. 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). En caso que el número no sea un número positivo de tres cifras, el programa debe imprimir el mensaje: "El número debe ser un entero positivo de tres cifras". //Programa que lee un entero de tres cifras y determina si son consecutivas.

66

Aprenda Java import java.util.Scanner; //para leer del teclado public class CifrasConsecutivas { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // lectura System.out.print("Número entero positivo de tres cifras? "); int numero = entrada.nextInt(); // verifica el rango if (numero >= 100 && numero <= 999) { // determina las cifras del número int centena = numero / 100; int decena = (numero % 100) / 10; int unidad = numero % 10; // determina si las cifras son consecutivas if ((decena == centena + 1 && unidad == decena + 1) || (decena == centena - 1 && unidad == decena - 1)) System.out.printf( "Las cifras de %d son consecutivas\n", numero); else System.out.printf( "Las cifras de %d no son consecutivas\n", numero); } // fin if else System.out.printf( "%d debe ser un número positivo de tres cifras\n", numero); } // fin del método main } // fin de la clase CifrasConsecutivas

Problema 6. 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. //Lee un número de tres cifras y obtiene el número mayor que //se pueden obtener con esas tres cifras. import java.util.Scanner; //para leer del teclado. public class TresCifras { public static void main(String[] args) { int a, b, c; Scanner entrada = new Scanner(System.in);

67

Aprenda Java // lectura System.out.print("Número 3 cifras? "); int numero = entrada.nextInt(); // proceso y salida a = numero / 100; numero = numero % 100; b = numero / 10; c = numero % 10; if (a > b) if (a > c) if (b > c) System.out.println(a + "" + b + else System.out.println(a + "" + c + else System.out.println(c + "" + a + "" + else if (b > c) if (c > a) System.out.println(b + "" + c + "" + else System.out.println(b + "" + a + "" + else System.out.println(c + "" + b + "" + a); } // fin del método main } // fin de la clase TresCifras

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

Problema 7. Escribe un programa, que dado como dato una temperatura en grados fahrenheit, determine el deporte que es apropiado practicar a esa temperatura, teniendo en cuenta la siguiente tabla: Deporte Temperatura Natación

> 85

Tenis

70 < TEMP ≤ 85

Golf

32 < TEMP ≤ 70

Esquí

10 < TEMP ≤ 32

Marcha

≤ 10

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

68

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

natación"); tenis"); golf"); esquí"); la marcha");

Problema 8. Cuatro números enteros entre 0 y 100 representan las puntuaciones de un estudiante de un curso de programación con Java. Escribe un programa para encontrar la media de estas puntuaciones y visualizar una tabla de notas de acuerdo a lo siguiente: • • • • •

Media (90-10), la puntuación es una letra A. Media (80-89), la puntuación es una letra B. Media (70-79), la puntuación es una letra C. Media (60-69), la puntuación es una letra D. Media (0-59), la puntuación es una letra F.

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

69

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

una A."); una B."); una C."); una D."); una F.");

Problema 9. Escribe un programa que solicitar una nota numérica entera entre 0 y 10, y mostrar dicha nota de la forma: cero, uno, dos, tres, etc. //Determina una nota numérica entre 0 y 10. import java.util.Scanner; //para leer del teclado public class NotaNumerica { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce una nota numérica entre 0 y 10: "); int numero = entrada.nextInt(); switch (numero) { case 0: System.out.println("CERO"); break; case 1: System.out.println("UNO"); break; case 2: System.out.println("DOS"); break; case 3: System.out.println("TRES");

70

Aprenda Java break; case 4: System.out.println("CUATRO"); break; case 5: System.out.println("CINCO"); break; case 6: System.out.println("SEIS"); break; case 7: System.out.println("SIETE"); break; case 8: System.out.println("OCHO"); break; case 9: System.out.println("NUEVE"); break; } // fin switch } // fin del método main } // fin de la clase NotaNumerica

Problema 10. Una cierta compañía fabricante de repuestos de automóviles ha descubierto defectos en algunos de sus productos, específicamente aquellos cuyos números de serie se encuentran dentro de los rangos: 14681 a 15681, 70001 a 79999 y 88888 a 111111. 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. //Determina si un número de serie es defectuoso o no. import java.util.Scanner; public class Repuestos { public static void main(String[] args) { int numeroSerie; boolean defectuoso1; boolean defectuoso2; boolean defectuoso3; // Prepara el teclado para la lectura de los datos Scanner entrada = new Scanner(System.in); System.out.println("Número de serie es defectuoso"); System.out.println("-----------------------------");

71

Aprenda Java

System.out.print("Numero serie? "); // indicador numeroSerie = entrada.nextInt(); defectuoso1 = (14681 <= numeroSerie && numeroSerie <= 15681); defectuoso2 = (70001 <= numeroSerie && numeroSerie <= 79999); defectuoso3 = (88888 <= numeroSerie && numeroSerie <= 111111); if (defectuoso1 || defectuoso2 || defectuoso3) System.out.printf( "El número de serie %d es defectuoso.\n", numeroSerie); else System.out.printf("El número de serie %d es correcto.\n", numeroSerie); } // fin del método main } // fin de la clase NumeroSerie

72

Aprenda Java

4. Instrucciones de repetición. Al finalizar esta lección, serás capaz de: •

Escribir programas que utilicen instrucciones de repetición.

4.1. Instrucción de repetición while. Una instrucción de repetición (también llamada instrucción de ciclo, ciclo, o bucles) nos permite especificar que un programa debe repetir una acción mientras que cierta condición sea verdadera. A las instrucciones a repetir se conocen como el cuerpo del ciclo y al hecho de repetir la secuencia de instrucciones se denomina iteración. La instrucción de repetición while permite que los programas repitan instrucciones mientras que una condición sea verdadera. En un ciclo while la condición se evalúa antes de cualquier repetición del ciclo. Si la condición es verdadera, el ciclo continúa. Si es falsa termina. El programa siguiente, ContadorWhile.java demuestra el uso de un ciclo while. //Programa que muestra la sintaxis para la instrucción while. public class ContadorWhile { public static void main(String[] args) { int contador = 1; // declara e inicializa // la variable de control while (contador <= 10) // condición de continuación de ciclo { System.out.println(contador); contador++; // 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 programa siguiente, CicloWhile.java, utiliza un ciclo controlado por contador. //Programa que muestra la sintaxis para la instrucción while. public class CicloWhile { public static void main(String[] args) { int contador = 10; // declara e inicializa // la variable de control while (contador > 0) // condición de continuación de ciclo

73

Aprenda Java {

System.out.println(contador); contador--; // 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. El programa siguiente, SumaWhile.java, utiliza un ciclo while para sumar los primeros n números naturales. //El programa suma los N primeros números naturales. import java.util.Scanner; //para leer del teclado public class SumaWhile { public static void main(String[] args) { int i = 1; // variable de control int suma = 0; // acumulador int n; // representa los n primeros número naturales Scanner entrada = new Scanner(System.in); // entrada System.out.print("Cantidad de números a sumar? "); n = entrada.nextInt(); // proceso while (i <= n) { suma += i; // suma = suma + i; i++; // i = i + 1; } // fin while // salida System.out.printf("La suma es %d\n", suma); } // fin del método main } // fin de la clase SumaNaturales

El programa siguiente, es una versión mejorada del programa, Adivinanza.java, que escribimos en la lección anterior. Esta versión permite seguir jugando hasta que el usuario adivine el número. //Programa para jugar adivinanzas. import java.util.Scanner; //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.random() * 101);

74

Aprenda Java

Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("Piensa un número entre 0 y 100."); System.out.println("-------------------------------"); int numero = -1; while (numero != numeroSecreto) { // solicita un número al usuario System.out.print("Número? "); numero = entrada.nextInt(); // evalúa if (numero == numeroSecreto) System.out.println("¡Adivinaste!"); else if (numero < numeroSecreto) System.out.println("¡Frío!"); else System.out.println("¡Caliente!"); } // fin while } // fin del método main } // fin de la clase Adivinanza

El programa siguiente, es una versión mejorada del programa, Suma.java, que escribimos en la lección anterior y que nos permite practicar sumas sencillas un determinado número de veces. //Programa para practicar sumas. import java.util.Scanner; //para leer del teclado public class Suma { public static void main(String[] args) { final int NUMERO_PREGUNTAS = 5; // número máximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 10); int numero2 = (int) (Math.random() * 10); // muestra la pregunta al usuario System.out.printf("¿Cuánto es %d + %d ? ",

75

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

correcta.");

incorrecta."); numero1, numero2,

? " correcto"

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

4.2. Ciclos controlados por un valor centinela. Un valor centinela (también llamada valor de señal, valor de prueba o valor de bandera) indica el fin de la introducción de datos en un ciclo. El programa siguiente, SumaCentinela.java, utiliza un ciclo while controlado por centinela para sumar una determinada cantidad de números enteros. //Programa para sumar números utilizando ciclo while/centinela. import java.util.Scanner; //para leer del teclado public class SumaCentinela { public static void main(String[] args) { int numero = 0; int suma = 0; Scanner entrada = new Scanner(System.in);

76

Aprenda Java System.out.print("Número a sumar (0 para terminar)? "); numero = entrada.nextInt(); // lectura while (numero != 0) { suma += numero; // suma = suma + numero; // lee el siguiente número System.out.print("Número a sumar (0 para terminar)? "); numero = entrada.nextInt(); // lectura } // fin while System.out.printf("La suma es %d", suma); } // fin del método main } // fin de la clase SumaCentinela

El programa siguiente, Promedio.java, utiliza un ciclo while controlado por centinela para calcular la suma y promedio de una serie de números. //Lee una serie de números enteros y calcula su promedio. import java.util.Scanner; //para leer del teclado public class Promedio { public static void main(String[] args) { int numero = 0; int contador = 0; int suma = 0; Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println( "Ingresa una lista de números enteros positivos."); System.out.println( "Marca el final de la lista con un núm negativo."); System.out.println( "Teclea la lista de núms: (ejemplo 4, 5, 4, 6, -3)"); numero = entrada.nextInt(); // lectura while (numero >= 0) { suma += numero; // suma = suma + numero; contador++; // contador = contador + 1; numero = entrada.nextInt(); // lectura } // fin while if (contador == 0) System.out.println("No ingresaste ningún número."); else { double promedio = (double) suma / contador; System.out.printf("%d números leídos.%n", contador); System.out.printf("El promedio es %.2f ", promedio); } // fin else

77

Aprenda Java } // fin del método main } // fin de la clase Promedio

4.3. Ciclos infinitos. Al estar trabajando con ciclos es posible que más de alguna vez provoquemos un ciclo infinito. Un ciclo infinito es aquel que no logra que su condición pueda concluir, y por tanto detenerse. El programa siguiente, CicloInfinito.java, demuestra los ciclos infinitos. //Demuestra los ciclos infinitos. public class CicloInfinito { public static void main(String[] args) { int suma = 0, i = 0; // este es un ciclo infinito while (i < 10) { suma = suma + i; // la variable de control i no cambia } // fin while int contador = 1; // otro ciclo infinito while (contador != 50) contador = contador + 2; // la condición no se cumple // otro ciclo infinito while (true) System.out.println("JavaJavaDo"); } // fin del método main } // fin de la clase CicloInfinito

No debemos utilizar valores en punto flotante como variables de control en un ciclo. Recuerda que los valores en punto flotante son valores aproximados y por lo tanto pueden producir resultados imprecisos. El programa siguiente, ErrorNumerico.java, demuestra como se produce un ciclo infinito con valores en punto flotante. //Ciclos con números en punto flotante. public class ErrorNumerico { public static void main(String[] args) { double item = 1; double suma = 0.0; while (item != 0) { // No se garantiza que item tome el valor 0 suma += item;

78

Aprenda Java item -= 0.1; System.out.println("Procesando...item vale " + item); } // fin while System.out.println(suma); } // fin del método main } // fin de la clase ErrorNumerico

4.4. Instrucción de repetición do/while. 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; por lo tanto, el cuerpo siempre se ejecuta por lo menos una vez. Cuando termina una instrucción do/while, la ejecución continúa con la siguiente instrucción en la secuencia. El programa siguiente, ContadorDoWhile.java, utiliza la instrucción de repetición do/while. //La instrucción de repetición do/while. public class ContadorDoWhile { public static void main(String[] args) { int contador = 1; // inicializa contador do {

System.out.printf("%d ", contador); contador++; // incrementa la variable de control } while (contador <= 10); // condición de continuación } // fin del método main } // fin de la clase ContadorDoWhile

Utilizamos el ciclo do/while cuando necesitamos por lo menos una repetición del ciclo. El programa siguiente, EncuentraUnTres.java, 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. public class EncuentraUnTres { public static void main(String[] args) { int numero; do {

numero = (int) (Math.random() * 20) + 1; System.out.println(numero); } while (numero != 3); System.out.println( "El programa ha terminado, he encontrado un 3.");

79

Aprenda Java } // fin del método main } // fin de la clase EncuentraUnTres

El programa siguiente, SumaCentinela.java, utiliza la instrucción de repetición do/while , para sumar una serie de números enteros. //Programa para sumar números utilizando ciclo do/while/centinela. import java.util.Scanner; //para leer del teclado public class SumaCentinela2 { public static void main(String[] args) { int numero = 0; int suma = 0; Scanner entrada = new Scanner(System.in); do { // lee el siguiente número System.out.print("Número a sumar (0 para terminar)? "); numero = entrada.nextInt(); // lectura suma += numero; // suma = suma + numero; } while (numero != 0); // fin do/while System.out.printf("La suma es %d", suma); } // fin del método main } // fin de la clase SumaCentinela2

4.5. Instrucción de repetición for. La instrucción while puede utilizarse para implementar cualquier ciclo controlado por un contador. Java, también cuenta con la instrucción for, que especifica los detalles de la repetición controlada por contador en una sola linea de código. El programa siguiente, CicloFor.java, ilustra la sintaxis básica para el ciclo for. //Muestra la estructura básica de la instrucción for. public class CicloFor { public static void main(String[] args) { for (int i = 0; i < 100; i++) System.out.println("JavaJavaDo"); } // fin del método main } // fin de la clase CicloFor

80

Aprenda Java En el ciclo for, tenemos una variable de control (o contador del ciclo), un valor inicial, el incremento o decremento de la variable de control y la condición de continuación del ciclo. El programa siguiente, ContadorFor.java, utiliza la instrucción de repetición for. //Repetición controlada con contador. public class ContadorFor { public static void main(String[] args) { // el encabezado de la instrucción for incluye // la iniacialización, la condición de continuación // del ciclo y el incremento/decremento for (int contador = 10; contador > 0; contador--) System.out.println(contador); // esto es un error // for( int i = 1; i < 10; i++ ); //genera un for vacío // System.out.println( i ); } // fin del método main } // fin de la clase ContadorFor

El programa siguiente, TablaMultiplicar.java, utiliza la instrucción de repetición for para imprimir una tabla de multiplicación. //El programa obtiene la tabla de múltiplicar de un número entero K. import java.util.Scanner; //para leer del teclado public class TablaMultiplicar { public static void main(String[] args) { int nTabla, mult; Scanner entrada = new Scanner(System.in); System.out.print("Tabla de multiplicar? "); nTabla = entrada.nextInt(); for (int i = 1; i <= 10; i++) { mult = nTabla * i; System.out.printf("%d x %d = %d\n", nTabla, i, mult); } // fin for } // fin del método main } // fin de la clase TablaMultiplicar

El programa siguiente, ParImpar.java, calcula la suma de números pares e impares. //Calcula la suma de los números pares e impares. public class ParImpar { public static void main(String[] args) { final int LIM_INF = 1;

81

Aprenda Java final int LIM_SUP = 200; int sumaPar = 0; int sumaImpar = 0; // proceso for (int i = LIM_INF; i <= LIM_SUP; i++) { if (i % 2 == 0) // ¿es par? sumaPar += i; // sumaPar = sumaPar + i; else sumaImpar += i; // sumaImpar = sumaImpar + i; } // fin for // salida System.out.printf("Suma pares: %d y Suma impares: %d\n", sumaPar, sumaImpar); } // fin del método main } // fin de la clase ParImpar

4.6. Ciclos anidados. Un ciclo anidado es un ciclo dentro de otro y los podemos combinar ( while, do/while,for) dependiendo de las necesidades de programación. El programa siguiente, TablasMultiplicar.java, utiliza dos ciclos for anidados para imprimir las tablas de múltiplicar del 1 al 10. //Imprime las tablas de multiplicar del 1 al 9. public class TablasMultiplicar { public static void main(String[] args) { for (int i = 1; i <= 9; i++) { for (int j = 1; j <= 10; j++) System.out.printf("%d x %d = %d\n", i, j, (i * j)); System.out.println(); } // fin for } // fin del método main } // fin de la clase TablasMultiplicar

El programa siguiente, ParejaValores.java, utiliza dos ciclos for anidados para imprimir una pareja de valores. //Imprime una pareja de valores. public class ParejaValores { public static void main(String[] args) { for (int i = 1; i <= 3; i++) for (int j = 1; j <= 2; j++) System.out.printf("%d\t%d\n", i, j);

82

Aprenda Java } // fin del método main } // fin de la clase ParejaValores

El programa siguiente, NumerosPerfectos.java, encuentra los tres primeros números perfectos. Un número perfecto es un entero positivo, que es igual a la suma de todos los enteros positivos (excluido el mismo) que son divisores del número. El primer número perfecto es 6, ya que los divisores de 6 son 1, 2, 3 y 1 + 2 +3 = 6. //El programa encuentra los tres primeros números perfectos. public class NumerosPerfectos { public static void main( String[] args ) { int contador = 0; int suma = 0; int numero = 3; //iniciamos la búsqueda a partir del 3 final int MAX = 3; while( contador < MAX ) { for( int i = 1; i < numero; i++ ) { if( numero % i == 0 ) suma += i; } //fin for if( suma == numero ) { System.out.printf("%d es un número perfecto\n", numero ); contador++; //incrementa el contador de números perfectos } //fin if numero++; //incrementa el número a buscar suma = 0; //inicializa el valor de suma } //fin while } //fin del método main } //fin de la clase NumerosPerfectos

4.7. Instrucción break y continue. Además de las instrucciones de selección y repetición, Java cuenta con las instrucciones break y continue para alterar el flujo de control de un programa. Anteriormente utilizamos la instrucción break para terminar la ejecución de una instrucción switch. Cuando break se ejecuta en una instrucción while, do/while, for o switch, ocasiona la salida inmediata de esa instrucción. La ejecución continúa con la primera instrucción después de la instrucción de control. Los usos comunes de break son para escapar anticipadamente del ciclo, o para omitir el resto de una instrucción switch. El programa siguiente, ForBreak.java, demuestra el uso de una instrucción break para salir de un ciclo for. 83

Aprenda Java

//La instrucción break para salir de un ciclo for. 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; // la variable de control también se usa // cuando termina el ciclo for (cuenta = 1; cuenta <= 10; cuenta++) // itera 10 veces { if (cuenta == 5) // si cuenta es 5 break; // termina el ciclo System.out.println(cuenta); } // fin de for System.out.println("Salio del ciclo en cuenta = " + cuenta); } // fin del método main } // fin de la clase ForBreak

Cuando la instrucción continue se ejecuta en una instrucción while, do/while o for, omite las instrucciones restantes en el cuerpo del ciclo y continúa con la siguiente iteración del ciclo. En las instrucciones while y do/while, el programa evalúa la prueba de continuación del ciclo justo después de que se ejecuta la instrucción continue. 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. El programa siguiente, ForContinue.java, utiliza la instrucción continue en un ciclo for. //Instrucción continue para terminar una iteración de una instrucción for. public class ForContinue { public static void main(String[] args) { for (int cuenta = 1; cuenta <= 10; cuenta++) // itera 10 veces { if (cuenta == 5) // si cuenta es 5, continue; // omite el resto del código en el ciclo System.out.printf("%d ", cuenta); } // fin de for System.out.println("\nSe uso continue para omitir imprimir 5"); } // fin del método main } // fin de la clase ForContinue

84

Aprenda Java El programa siguiente, NumeroPrimo.java, determina si un número es primo. Un número es primo si tiene únicamente dos divisores: 1 y el mismo número. Por ejemplo, 3 es primo porque sus únicos divisores son 1 y 3; en cambio 8 no es primo porque a parte del 1 y el 8 tiene otros divisores. //Programa que determina si un número es primo o no. import java.util.Scanner; //para leer del teclado public class NumeroPrimo { public static void main(String[] args) { boolean esPrimo = true; int numero; Scanner entrada = new Scanner(System.in); // entrada System.out.print("n? "); numero = entrada.nextInt(); // proceso for (int i = 2; i if (numero % esPrimo break; } // fin if } // fin for

<= numero / 2; i++) { i == 0) { // ¿es primo? = false; // no es primo // termina el ciclo

// salida if (esPrimo) System.out.printf(" %d es primo\n", numero); else System.out.printf(" %d no es primo\n", numero); } // fin del método main } // fin de la clase NumeroPrimo

El programa siguiente, NumerosPrimos.java, imprime los primeros 50 números primos. //Programa que imprime los primeros 50 números primos. public class NumerosPrimos { public static void main(String[] args) { final int MAX_PRIMOS = 50; // número de primos a imprimir final int NUMERO_POR_LINEA = 10; // número de primos por línea int contador = 0; // contador para los número primos int numero = 2; // Valor inicial para la búsqueda de primos // mensaje de usuario System.out.println("Los 50 números primos son:\n");

85

Aprenda Java // encuentra los números primos while (contador < MAX_PRIMOS) { // asume que el número es primo boolean esPrimo = true; // determina si el número es primo for (int divisor = 2; divisor <= numero / 2; divisor++) { if (numero % divisor == 0) { esPrimo = false; // el número no es primo break; // termina el ciclo } // fin if } // fin for // Imprime el número primo e incrementa el contador if (esPrimo) { contador++; // incrementa el contador de primos if (contador % NUMERO_POR_LINEA == 0) { // inicia una nueva línea System.out.println(numero); } // fin if else { System.out.print(numero + "\t"); } // fin else } // fin if // busca si el siguiente número es primo numero++; } // fin while } // fin del método main } // fin de la clase NumerosPrimos

4.8. Ejercicios resueltos. 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. Nota: los problemas que se resuelven aquí no tienen una solución única. Problema 1. Escribe un programa que lea un número entero y que imprima su cuadrado; el proceso debe repetirse hasta que se introduzca un número negativo. //Imprime el cuadrado de un número hasta que se introduce //un número negativo.

86

Aprenda Java import java.util.Scanner; //para leer del teclado public class Cuadrado { public static void main(String[] args) { int numero; int cuadrado; Scanner entrada = new Scanner(System.in); System.out.print("Introduce un número entero: "); numero = entrada.nextInt(); while (numero >= 0) { cuadrado = numero * numero; System.out.printf("El cuadrado de %d es %d\n", numero, cuadrado); // el ciclo se repite hasta que se lea un numero negativo System.out.print("Introduce otro número entero: "); numero = entrada.nextInt(); } // fin while System.out.println(">>>Fin del programa..."); } // fin del método main } // fin de la clase Cuadrado

Problema 2. Escribir un programa que lea un número entero e indique si es un número positivo o negativo. El proceso se repetirá hasta que se introduzca un 0. //Imprime si un número es positivo/negativo hasta que se //introduce un número cero. import java.util.Scanner; //para leer del teclado public class PositivoNegativo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Introduce un número positivo/negativo. "); System.out.print("(0 para terminar)? "); int numero = entrada.nextInt(); while (numero != 0) { if (numero > 0) System.out.printf("%d es positivo\n", numero); else System.out.printf("%d es negativo\n", numero);

87

Aprenda Java

// el ciclo se repite hasta que se lea un cero System.out.println( "Introduce otro número positivo/negativo."); System.out.print("(0 para terminar)? "); numero = entrada.nextInt(); } // fin while System.out.println(">>>Fin del programa..."); } // fin del método main } // fin de la clase PositivoNegativo

Problema 3. Escribe un programa que lea un número entero y sume los dígitos individuales de ese número. Por ejemplo para el número 234 el resultado es 9. //Suma los dígitos de un número. import java.util.Scanner; //para leer del teclado public class SumaDigitos { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int suma = 0; int temporal = 0; int digito = 0; System.out.println("Suma los dígitos de un número."); System.out.println("------------------------------"); System.out.print("Número? "); numero = entrada.nextInt(); temporal = numero; while (temporal > 0) { // obtiene el dígito digito = temporal % 10; // lo suma suma += digito; // recorta la cifra temporal = temporal / 10; } // fin while System.out.printf("La suma de los dígitos de %d es %d", numero, suma); } // fin del método main } // fin de la clase SumaDigitos

88

Aprenda Java Problema 4. Escribe un programa que lea un número entero y determine si es el número es palíndromo. Por ejemplo: 12321, 55555, 45554 son números palíndromos. //Determina si un número es palíndromo. import java.util.Scanner; //para leer del teclado public class Palindromo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int inverso = 0; int temporal = 0; int digito = 0; System.out.println("Determina si un número es palíndromo."); System.out.println("-------------------------------------"); System.out.print("Número? "); numero = entrada.nextInt(); temporal = numero; while (temporal > 0) { // obtiene el dígito digito = temporal % 10; // forma el número inverso inverso = (inverso * 10) + digito; // recorta la cifra temporal = temporal / 10; } // fin while if (numero == inverso) System.out.printf("%d es palíndromo", numero); else System.out.printf("%d no es palíndromo", numero); } // fin del método main } // fin de la clase Palindromo

Problema 5. La siguiente se llama la conjetura de ULAM en honor del matemático S.Ulam: • • •

Comience con cualquier entero positivo. Si es par, divídalo entre 2; si es impar, multípliquelo por 3 y agréguele 1. Obtenga enteros sucesivamente repitiendo el proceso.

•

Al final, obtendrá el número 1, independientemente del entero inicial. Por ejemplo, cuando el 89

Aprenda Java entero inicial es 26, la secuencia será: 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1. Escribe un programa que lea un entero positivo y obtenga e imprima la sucesión de ULAM. //Imprime la serie para la conjetura de ULAM. import java.util.Scanner; //para leer del teclado public class ConjeturaUlam { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.println("Conjetura de ULAM"); System.out.println("-----------------"); System.out.print("Introduce un número entero: "); int numero = entrada.nextInt(); while (numero != 1) { if (numero % 2 == 0) numero = numero / 2; else numero = numero * 3 + 1; System.out.println(numero); } // fin while } // fin del método main } // fin de la clase ConjeturaUlam

Problema 6. Escribir un programa que imprima y obtenga la suma de los términos de la siguiente serie: 2, 5, 7, 10, 12, 15, 17, ..., 1800. //El programa imprime y suma los términos de una serie. //2, 5, 7, 10, 12, 15, 17, ..., 1800. public class Serie1 { public static void main( String[] args ) { final int LIMITE = 1800; final int NUMERO_POR_LINEA = 10; int contador = 0; //cuenta los números por renglón int i = 2; int sumaSerie = 0; boolean indicador = true; while( i <= LIMITE ) { sumaSerie += i; contador++; //cuenta los números por línea

90

Aprenda Java

//imprime la serie if( contador % NUMERO_POR_LINEA == 0 ) System.out.println(i); else System.out.print( i + "\t");

} } }

if( indicador ) { i += 3; indicador = false; } //end if else { i += 2; indicador = true; } //fin else //fin while

System.out.printf( "\nLa suma de la serie es %d", sumaSerie ); //fin del método main //fin de la clase SumaSerie1

Problema 7. Escribe un programa que lea un número entero N y calcule el resultado de la siguiente serie: 1 1 1 1 1+ + + + ...+ 2 3 4 N //Calcula el resultado de una determinada serie. import java.util.Scanner; public class Serie2 { public static void main(String[] args) { double serie = 0.0; Scanner entrada = new Scanner(System.in); System.out.println("Calcula la suma de la serie:"); System.out.println("1 + 1/2 + 1/3 + ... + 1/n"); System.out.println("----------------------------"); // entrada System.out.print("Introduce el número n: "); int numero = entrada.nextInt(); // proceso for (int i = 1; i <= numero; i++) serie = serie + 1.0 / i;

91

Aprenda Java // salida System.out.printf("La suma de la serie es %.2f\n", serie); } // fin del método main } // fin de la clase Serie2

Problema 8. Escribe un programa que lea un número entero N y calcule el resultado de la siguiente serie: 1 1 1 1 1− + − + ...± 2 3 4 N //Calcula el resultado de una serie determinada. import java.util.Scanner; //para leer del teclado public class Serie3 { public static void main(String[] args) { double serie = 0.0; boolean bandera = true; Scanner entrada = new Scanner(System.in); System.out.println("Calcula la suma de la serie:"); System.out.println("1 - 1/2 + 1/3 - 1/4 ... +- 1/n"); System.out.println("------------------------------"); System.out.print("Introduce el número n: "); int numero = entrada.nextInt(); for (int i = 1; i <= numero; i++) { if (bandera) { serie += 1.0 / i; bandera = false; } // fin if else { serie -= 1.0 / i; bandera = true; } // fin else } // fin for System.out.printf("La suma de la serie es %.2f\n", serie); } // fin del método main } // fin de la clase Serie3

92

Aprenda Java Problema 9. Escribe un programa que calcule el factorial de un número. Por ejemplo, el factorial de 4! = 4 x 3 x 2 x 1. //Calcula el factorial de un número. 5!= 4x3x2x1. import java.util.Scanner; //para leer del teclado public class Factorial { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int numero = 0; int factorial = 1; System.out.println("Factorial de un número."); System.out.println("-----------------------"); System.out.print("Número? "); numero = entrada.nextInt(); for (int i = 2; i <= numero; i++) factorial *= i; System.out.printf( "El factorial de %d! es %d", numero, factorial); } // fin del método main } // fin de la clase Factorial

Problema 10. Escribe un programa que calcule el término 20 de la secuencia de FIBONACCI. Recuerda que los dos primeros números de la serie son 0 y 1. El resto se calcula como la suma de los dos inmediatos números que le preceden. Ejemplo de la serie: 0, 1, 2, 3, 5, 8, 13, 21, 34, 55,...n. //Calcula el término 20 de la secuencia de Fibonacci. //Ejemplo de la serie: 0, 1, 2, 3, 5, 8, 13, 21, 34, 55,...n public class Fibonacci { public static void main(String[] args) { final int NUMERO_POR_LINEA = 10; // número de primos por línea int contador = 0; // contador de la secuencia de números int n1 = 0; // primer valor de la serie int n2 = 1; // el valor siguiente int siguiente; System.out.println( "Serie de Fibonacci." ); System.out.println( "-------------------" );

93

Aprenda Java

for (int i = 3; i <= 22; i++) { siguiente = n1 + n2; n1 = n2; n2 = siguiente; contador++; // incrementa el contador de números if (contador % NUMERO_POR_LINEA == 0) { // inicia una nueva línea System.out.println(siguiente); } // fin if else { System.out.print(siguiente + "\t"); } // fin else } // fin for } // fin del método main } // fin de la clase Fibonacci

94

Aprenda Java

5. Utilización de métodos pre-construidos. Al finalizar esta lección, serás capaz de: •

Conocer algunos métodos pre-construidos de la API de Java tales como los de la clase Math, String, el método printf de System.out, NumberFormat y DecimalFormat.

5.1. Métodos de la clase Math. Java contiene muchas clases predefinidas que se agrupan en categorías de clases relacionadas, llamadas paquetes. En conjunto, nos referimos a estos paquetes como la Interfaz de Programación de Aplicaciones de Java (API de Java), o biblioteca de clases de Java. La clase Math es una de las clases pre-construidas en el paquete java.lang. Esta clase contiene métodos que implementan funciones matemáticas estándar. Además de proveer métodos matemáticos, la clase Math también provee dos constantes matemáticas: PI y e (la base para los logaritmos naturales). Todos los métodos en la clase Math son static. 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. El programa siguiente, MathDemo.java utiliza algunos métodos de la clase Math. //Utiliza algunos métodos de la clase Math. public class MathDemo { public static void main(String[] args) { // el valor absoluto System.out.println(Math.abs(23.7)); // 23.7 System.out.println(Math.abs(0.0)); // 0.0 System.out.println(Math.abs(-23.7)); // 23.7 System.out.println(); // redondea x al entero más pequeño que no sea menor de x System.out.println(Math.ceil(9.2)); // 10.0 System.out.println(Math.ceil(-9.8)); // -9 System.out.println(); // redondea x al entero más grande que no sea mayor que x System.out.println(Math.floor(9.2)); // 9.0 System.out.println(Math.floor(-9.8)); // -10 System.out.println(); // el valor más grande de x y y System.out.println(Math.max(2.3, 12.7)); // 12.7 System.out.println(Math.max(-2.3, -12.7)); // -2.3 System.out.println(); // el valor más pequeño de x y y

95

Aprenda Java System.out.println(Math.min(2.3, 12.7)); // 2.3 System.out.println(Math.min(-2.3, -12.7)); // -12.7 System.out.println(); // La raíz cuadrada de x System.out.println(Math.sqrt(9)); // 3 System.out.println(); // x elevado a la potencia y System.out.println(Math.pow(2, 3)); // 8 System.out.println(Math.pow(9, 0.5)); // 3 System.out.println(); // genera un número aleatorio 0..1 sin incluir el 1 System.out.println(Math.random()); } // 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. El programa siguiente MayorMenor.java nos ilustra las ventajas de utilizar métodos preconstruidos. //Demuestra el uso de Math.min y Math.max. import java.util.Scanner; //para leer del teclado import static java.lang.Math.*; public class MayorMenor { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Introduce tres números: "); int num1 = entrada.nextInt(); int num2 = entrada.nextInt(); int num3 = entrada.nextInt(); // // // //

evitar reinventar la rueda...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, max(num2, num3)); // encuentra el menor int menor = min(num1, min(num2, num3)); System.out.printf("El mayor es %d%n", mayor); System.out.printf("El menor es %d%n", menor); } // fin del método main

96

Aprenda Java } // fin de la clase MayorMenor

5.2. Formateo de la salida. El método printf de la clase System nos permite imprimir texto formateado. El programa siguiente, PrintfDemo.java, ilustra como utilizar algunos especificadores de formato para imprimir texto formateado. //Demuestra el formato de cadenas con printf public class PrintfDemo { public static void main(String[] args) { System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // imprime un número entero System.out.printf("%d %n", 1974); // agrega un cero a los espacios restantes System.out.printf("%08d %n", 1974); // si no se especifica el cero se usa un caracter vacío System.out.printf("%8d %n", 1974); // signo positivo y negativo System.out.printf("+%d %n", 1974); System.out.printf("-%d %n", 1974); // agregando el separador de coma System.out.printf("%,d %n%n", 1974); System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // imprime un número en punto flotante System.out.printf("%f %n", Math.PI); // 3 digitos después del punto decimal System.out.printf("%.3f %n", Math.PI); // 8 caracteres y 2 digitos System.out.printf("%8.3f %n", Math.PI); } // fin del método main } // fin de la clase PrintfDemo

El programa siguiente PrintfTabla.java es otro ejemplo de como imprimir texto formateado. //Utiliza printf para dar formato a una tabla. public class PrintfTabla { public static void main(String[] args) { // imprime un encabezado System.out.printf("%s%10s%8s%n", "Num", "Cuadrado", "Triple"); System.out.println("---------------------");

97

Aprenda Java

for (int i = 1; i <= 10; i++) System.out.printf("%3d%10d%8d%n", i, i * i, i * i * i); } // fin del 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. Este método trabaja de la misma manera que el método printf de la clase System. El programa siguiente, StringFormatDemo.java, muestra como dar formato al texto. //Demuestra el formato de cadenas con String.format. public class StringFormatDemo { public static void main(String[] args) { System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // imprime un número entero String cad = String.format("%d", 1974); System.out.println(cad); // agrega un cero a los espacios restantes cad = String.format("%08d", 1974); System.out.println(cad); // si no se especifica el cero se usa un caracter vacío cad = String.format("%8d", 1974); System.out.println(cad); // signo positivo y negativo cad = String.format("+%d", 1974); System.out.println(cad); cad = String.format("-%d", 1974); System.out.println(cad); // agregando el separador de coma cad = String.format("%,d %n%n", 1974); System.out.printf(cad);

}

System.out.println("123456789012345678901234567890123456789"); System.out.println("---------+---------+---------+---------"); // imprime un número en punto flotante cad = String.format("%f", Math.PI); System.out.println(cad); // 3 digitos después del punto decimal cad = String.format("%.3f", Math.PI); System.out.println(cad); // 8 caracteres y 2 digitos cad = String.format("%8.3f", Math.PI); System.out.println(cad); } //fin del método main //fin de la clase StringFormatDemo

98

Aprenda Java

5.3. Métodos de la clase String. La clase String es otra de las clases del paquete java.lang. La clase String contiene muchos métodos útiles para la manipulación de cadenas. El programa siguiente StringDemo.java utiliza algunos métodos de la clase String. //Demuestra algunos métodos de la clase String. public class StringDemo { public static void main(String[] args) { String mensaje = "Ahora es el tiempo de Java"; System.out.println("012345678901234567890123456789"); System.out.println("+--------+---------+---------+"); System.out.println(mensaje); System.out.println(mensaje.charAt(6)); // e System.out.println(mensaje.length()); // 26 System.out.println(mensaje.indexOf('e')); // 6 System.out.println(mensaje.indexOf("es")); // 6 System.out.println(mensaje.substring(19)); // de Java System.out.println(mensaje.substring(0, 6)); // de Java System.out.println(mensaje.toLowerCase()); System.out.println(mensaje.toUpperCase()); System.out.println(mensaje.replace('e', '9')); } // fin del método main } // fin de la clase StringDemo

El programa siguiente, CompararString.java, muestra como se deben comparar dos cadenas en Java. //Ilustra como comparar cadenas. public class CompararString { public static void main(String[] args) { String cadUno = new String("Java"); String cadDos = new String("CSharp"); // la forma incorrecta de comparar dos cadenas if (cadUno == cadDos) System.out.println("Son iguales"); else System.out.println("No son iguales");

99

Aprenda Java // la forma correcta if (cadUno.equals("Java")) System.out.println("Son iguales (Java)"); else System.out.println("No son iguales"); if (cadDos.equalsIgnoreCase("CSHARP")) System.out.println("Son iguales (CSharp)"); else System.out.println("No son iguales"); } // fin del método main } // fin de la clase CompararString

5.4. Formateo de números. La clase NumberFormat se utiliza para formatear números permitiendo que el código sea independiente de las convenciones propias de cada país. El programa siguiente, NumberFormatDemo.java, ilustra lo anterior. //Demuestra el formato para las monedas import java.text.NumberFormat; import java.util.Locale; //para usar formatos de otros paises public class NumberFormatDemo { public static void main(String[] args) { System.out.println("Números sin formato:"); System.out.println(19.8); System.out.println(19.81111); System.out.println(19.89999); System.out.println(19); System.out.println(); System.out.println("Usando el formato por default:"); NumberFormat moneda = NumberFormat.getCurrencyInstance(); // observa los números redondeados System.out.println(moneda.format(19.8)); System.out.println(moneda.format(19.81111)); System.out.println(moneda.format(19.89999)); System.out.println(moneda.format(19)); System.out.println(); System.out.println("Usando el formato de UK:"); NumberFormat monedaUK = NumberFormat.getCurrencyInstance(Locale.UK); System.out.println(monedaUK.format(19.8)); System.out.println(monedaUK.format(19.81111)); System.out.println(monedaUK.format(19.89999));

100

Aprenda Java System.out.println(monedaUK.format(19)); } // fin del método main } // fin de la clase NumberFormatDemo

La clase DecimalFormat nos permite mostrar números con un formato deseado, es decir, limitar el número de decimales, si usaremos punto o coma, etc. El programa siguiente, DecimalFormatDemo.java, ilustra lo anterior. //Demuestra el formato para números import java.text.DecimalFormat; public class DecimalFormatDemo { public static void main(String[] args) { DecimalFormat patron1 = new DecimalFormat("00.000"); DecimalFormat patron2 = new DecimalFormat("0.00"); double numero = 2.3456789; System.out.println("Patrón 1: 00.000"); System.out.println(patron1.format(numero)); System.out.println("Patrón 2: 0.00"); System.out.println(patron2.format(numero)); DecimalFormat patron3 = new DecimalFormat("##.###"); DecimalFormat patron4 = new DecimalFormat("#.##"); System.out.println("Patrón 3: ##.###"); System.out.println(patron3.format(numero)); System.out.println("Patrón 4: #.##"); System.out.println(patron4.format(numero)); DecimalFormat porcentaje1 = new DecimalFormat("0.00%"); System.out.println("Patrón 5: 0.00%"); System.out.println(porcentaje1.format(0.308)); DecimalFormat porcentaje2 = new DecimalFormat("#.##%"); System.out.println("Patrón 6: #.##%"); System.out.println(porcentaje2.format(0.308)); } // fin del método main } // fin de la clase DecimalFormatDemo

101

Aprenda Java

6. Métodos. Al finalizar esta lección, serás capaz de: •

Utilizar la programación modular mediante métodos void y con valor de retorno en los programas Java.

6.1. Programación modular. 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. Para ello se parte de un módulo principal que se descompone en varios submódulos que son controlados por el módulo principal. 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. A este proceso de refinamiento sucesivo se conoce también como la técnica de “divide y vencerás”. Las tareas asignadas a los subprogramas pueden ser de diversa índole: entrada, salida, cálculos, control de otros módulos, etc. 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. Una vez que el subprograma termina su tarea, devuelve el control al punto donde se hizo la llamada. Un subprograma puede llamar a su vez a otros subprogramas. En el lenguaje Java a los módulos o subprogramas se les conoce con el nombre de métodos.

6.2. Métodos void. Un método tipo void es un módulo de programa que puede recibir datos de entrada a través de parámetros; pero, que no retorna ningún resultado al punto donde es invocado, razón por el que se le conoce también como método sin valor de retorno. Los métodos tipo void pueden dividirse a su vez en dos tipos: • •

Métodos tipo void sin parámetros. Métodos tipo void con parámetros.

6.3 Métodos void sin parámetros. Estos métodos no pueden recibir datos de entrada ni retornar ningún resultado al punto de su invocación. El programa siguiente, TestMetodoVoid.java, ilustra lo mencionado anteriormente.

102

Aprenda Java //Define y utiliza un método void. public class TestMetodoVoid { public static void saludo() { System.out.println("¡Saludos programador Java!"); } // fin del método saludo public static void main(String[] args) { // invoca al método static saludo(); } // 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. En este curso utilizaremos métodos con el modificador static. Estudiemos otro ejemplo. El programa siguiente, Temperatura.java, utiliza métodos void para convertir de celsius a fahrenheit respectivamente. //Utiliza dos métodos para convertir de celsius a fahrenheit y viceversa. import java.util.Scanner; //para leer del teclado public class Temperatura { // convierte de Fahrenheit a Celsius public static void fahrenheitCelsius() { double fahrenheit, celsius; // variables locales Scanner entrada = new Scanner(System.in); // lee la temperatura System.out.print("Ingresa una temperatura en Fahrenheit: "); fahrenheit = entrada.nextDouble(); // realiza la conversión celsius = 5.0 / 9.0 * fahrenheit - 32; // imprime el resultado System.out.printf("La temperatura en Celsius es %.2f%n", celsius); } // fin del método fahrenheitCelsius // convierte de celsius a fahrenheit public static void celsiusFahrenheit() { double fahrenheit, celsius; // variables locales Scanner entrada = new Scanner(System.in); // lee la temperatura System.out.print("Ingresa una temperatura en Celsius: ");

103

Aprenda Java celsius = entrada.nextDouble(); // realiza la conversión fahrenheit = 9.0 / 5.0 * celsius + 32; // imprime el resultado System.out.printf("La temperatura en Fahrenheit es %.2f%n", fahrenheit); } // fin del método celsiusFahrenheit public static void main(String[] args) { int opcion; // variable local Scanner entrada = new Scanner(System.in); // mensaje de usuario System.out.println("1. Convertir de Fahrenheit a Celsius."); System.out.println("2. Convertir de Celsius a Fahrenheit."); // lee la opción del usuario System.out.print("Opción: "); opcion = entrada.nextInt(); if (opcion == 1) fahrenheitCelsius(); else celsiusFahrenheit(); } // fin del método main } // fin de la clase Temperatura

6.4. Métodos void con parámetros. Estos métodos reciben datos de entrada a través de parámetros; pero, al igual que en el caso anterior no pueden retornar ningún resultado al punto de su invocación. El número de parámetros es variable y depende de las necesidades del método. El programa siguiente, Curso.java, declara y utiliza un método con un parámetro para imprimir un mensaje de texto dependiendo del valor que se recibe como argumento. //Declaración de un método con un parámetro. public class Curso { // muestra un mensaje de bienvenida public static void mostrarMensaje(String nombreCurso) { System.out.printf("Bienvenido al curso de %s%n", nombreCurso); } // fin del método mostrarMensaje public static void main(String[] args) { mostrarMensaje("Java"); // llamada al método

104

Aprenda Java mostrarMensaje("C Sharp"); // llamada al método } // fin del método main } // fin de la clase Curso

El programa siguiente, NotaExamen.java, recibe como dato de entrada una calificación e imprime una nota. //Define un método void que recibe un valor como argumento. public class NotaExamen { public static void calificar(double calificacion) { if (calificacion >= 90.0) System.out.println('A'); else if (calificacion >= 80.0) System.out.println('B'); else if (calificacion >= 70.0) System.out.println('C'); else if (calificacion >= 60.0) System.out.println('D'); else System.out.println('F'); } // fin del método calificar public static void main(String[] args) { System.out.print("Obtuviste una "); calificar(78.5); System.out.print("Obtuviste una "); calificar(59.5); } // fin del método main } // fin de la clase NotaExamen

6.5. Métodos return. 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. Este tipo de método se utiliza para efectuar cualquier tipo de proceso que produzca un resultado . Estos métodos pueden dividirse a su vez en dos tipos: • •

Métodos con valor de retorno sin parámetros. Métodos con valor de retorno con parámetros.

105

Aprenda Java

6.6. Métodos return, sin parámetros. Este tipo de métodos no reciben datos de entrada; pero, retornan un resultado al punto donde son invocados. El programa siguiente, TestMetodoReturn.java, define un método con valor de retorno, sin parámetros. //Define y utiliza un método return public class TestMetodoReturn { public static String saludo() { return "¡Saludos programador Java!"; } // fin del método saludo public static void main(String[] args) { // invoca al método static System.out.println(saludo()); } // fin del método main } // fin de la clase TestMetodoReturn

Recuerda: siempre que en el encabezado de un método sea diferente de void, el método debe devolver un valor a través de la instrucción return, y el tipo de valor debe coincidir con el especificado en el encabezado del método.

6.7. Métodos return con parámetros. Estos métodos reciben datos de entrada a través de parámetros y retornan un resultado al punto de su invocación. El programa siguiente, AreaCirculo.java declara y utiliza un método con valor de retorno con un parámetro. //Utiliza un método con un parámetro para calcular //el área de un círculo. import java.util.Scanner; //para leer del teclado public class AreaCirculo { // calcula el area de un circulo public static double area(double radio) { return (Math.PI * Math.pow(radio, 2)); } // fin del método area public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Radio del círculo:? "); double radio = entrada.nextDouble(); System.out.printf("El radio del circulo es de %.2f cms.%n", radio);

106

Aprenda Java System.out.printf("El área del circulo es de %.2f cms.", area(radio)); } // fin del método main } // fin de la clase AreaCirculo

El programa siguiente, PieMetro.java, declara y utiliza dos métodos con valor de retorno y un parámetro para calcular la equivalencia pie a metro y viceversa. //Convierte pies a metros y viceversa. public class PieMetro { public static double pieMetro(double pie) { return 0.305 * pie; } // fin del método pieMetro public static double metroPie(double metro) { return metro / 0.305; } // fin del método metroPie public static void main(String[] args) { final int MAX = 10; double pies = 1.0; // valor inicial double metros = 20.0; // valor inicial System.out.printf("%s%9s%9s%9s%n", " Pies", "Metros", "Metros", "Pies"); for (int i = 1; i <= MAX; i++) { System.out.printf("%6.2f%9.2f%9.2f%9.2f%n", pies, pieMetro(pies), metros, metroPie(metros)); pies++; // incrementa los pies metros += 5; // incrementa los metros } // fin for } // fin del método main } // fin de la clase PiesMetros

El programa siguiente, PrimosGemelos.java, encuentra los primeros 10 números primos gemelos. Por ejemplo, 2 y 3 son los únicos primos seguidos. Pero hay un gran número de pares de números primos que difieren en dos unidades, por ejemplo: 3 y 5, 5 y 7, 11 y 13, etc. //Encuentra los 10 primeros números primos gemelos. //(3,5),(5,7),(11,13)...etc. public class PrimosGemelos { // determina si un número es primo public static boolean esPrimo(int n) { for (int divisor = 2; divisor <= n / 2; divisor++)

107

Aprenda Java if (n % divisor == 0) // ¿es divisible? return false; // el número no es primo return true; // el número es primo } // fin del método esPrimo public static void main(String[] args) { final int MAX_PRIMOS = 10; int contador = 0; // cuenta el número de primos int numero = 2; // 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.out.printf( "%d y %d son primos gemelos\n", numero, numero + 2); contador++; // incrementa contador primos } } // fin if numero++; // para buscar el siguiente primo } // fin while } // fin del método main } // fin de la clase PrimosGemelos

El programa siguiente, ParesPrimos.java, declara y utiliza un método esPrimo para determinar si un número es primo. El método esPrimo se utiliza como auxiliar para determinar en un rango de números aquellos pares primos (AB, CD) donde ABCD también es primo. //Encuentra todos los pares primos (AB,CD) donde ABCD también es primo. public class ParesPrimos { // determina si un número es primo private static boolean esPrimo(int n) { for (int divisor = 2; divisor <= n / 2; divisor++) if (n % divisor == 0) // ¿es divisible? return false; // el número no es primo return true; // el número es primo } // fin del método esPrimo public static void main(String[] args) { final int MAX = 9999; int numero = 1001; // inicia búsqueda int ab = 0, cd = 0; // repetidamente encuentra los pares primos

108

Aprenda Java while (numero < MAX) { if (esPrimo(numero)) { // es primo? ab = numero / 100; cd = numero % 100; if (esPrimo(ab) && esPrimo(cd)) System.out.printf("Primo ABCD: %d (%d)(%d)\n", numero, ab, cd); } // fin if numero++; // para buscar el siguiente primo } // fin while } // fin del método main } // fin de la clase ParesPrimos

Un método puede especificar múltiples parámetros; sólo hay que separar un parámetro de otro mediante una coma (lista separada por comas). El programa siguiente, BuscadorMaximo.java, declara y utiliza un método con múltiples parámetros. //Método máximo, declarado por el programador. import java.util.Scanner; //para leer del teclado public class BuscadorMaximo { // devuelve el máximo de sus tres parámetros double public static double maximo(double x, double y, double z) { double valorMaximo = x; // asume que x es el mayor para empezar // determina si y es el mayor que valorMaximo if (y > valorMaximo) valorMaximo = y; // determina si z es mayor que valorMaximo if (z > valorMaximo) valorMaximo = z; return valorMaximo; } // fin del método máximo public static void determinarMaximo() { Scanner entrada = new Scanner(System.in); // entrada System.out.print( "Escribe tres double numero1 = double numero2 = double numero3 =

números, separados por espacios: "); entrada.nextDouble(); entrada.nextDouble(); entrada.nextDouble();

// determina el valor máximo

109

Aprenda Java double resultado = maximo(numero1, numero2, numero3); // muestra el valor máximo System.out.println("El máximo es: " + resultado); } // fin del método determinarMaximo public static void main(String[] args) { // llama al método static determinarMaximo(); } // fin del método main } // fin de la clase BuscadorMaximo

6.8. Compatibilidad de argumentos y parámetros. 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ó. Además, 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. El programa siguiente, PasoParametros.java, demuestra la compatibilidad de argumentos y parámetros. //Demuestra la compatibilidad entre argumentos y parámetros. public class PasoParametros { public static void nPrint(String mensaje, int n) { for (int i = 0; i < n; i++) System.out.println(mensaje); } // fin del método nPrint public static void main(String[] args) { nPrint("Hola", 3); // El orden de los parámetros es correcto // nPrint( 3, "Hola" ); //El orden es incorrecto // nPrint( "Hola", 3.5 ); //El tipo es incorrecto // nPrint(); //faltan argumentos // nPrint( "Hola" ); //faltan argumentos // nPront( "Hola, 2"); //el 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. Las reglas de promoción especifican qué conversiones son permitidas; esto es, qué conversiones pueden realizarse sin perder datos. El programa siguiente, PasoParametros2.java ilustra lo mencionado anteriormente. 110

Aprenda Java

//Demuestra la compatibilidad entre argumentos y parámetros. public class PasoParametros2 { public static double cuadrado(double n) { return n * n; } // fin del método cuadrado public static void main(String[] args) { System.out.println(cuadrado(3)); // 3 -> 3.0 System.out.println(cuadrado(3.0F)); // 3.0F -> 3.0 System.out.println(cuadrado(3.0)); // el argumento es correcto // System.out.println( cuadrado() ); //falta el argumento // System.out.println( cuadrado("3") ); //el tipo es incorrecto } // fin del método main } // fin de la clase PasoParametros2

6.9. Métodos sobrecargados (overload). Pueden declararse métodos con el mismo nombre en la misma clase, siempre y cuando tengan distintos conjuntos de parámetros (determinados en base al número, tipos y orden de los parámetros). A esto se le conoce como sobrecarga de métodos. Cuando se hace una llamada a un método sobrecargado, el compilador de Java selecciona el método apropiado mediante un análisis del número, tipos y orden de los argumentos en la llamada. Por lo general, la sobrecarga de métodos se utiliza para crear varios métodos con el mismo nombre que realicen la misma tarea o tareas similares. El programa siguiente, Sobrecarga.java, utiliza métodos sobrecargados. //Declaraciones de métodos sobrecargados. public class Sobrecarga { // método al cuadrado con argumento int public static int cuadrado(int valorInt) { System.out.printf( "\nSe llamo a cuadrado con argumento int: %d\n", valorInt); return valorInt * valorInt; } // fin del método cuadrado con argumento int // método al cuadrado con argumento double public static double cuadrado(double valorDouble) { System.out.printf(" \nSe llamo a cuadrado con argumento double: %f\n", valorDouble); return valorDouble * valorDouble; } // fin del método cuadrado con argumento double // prueba los métodos cuadrado sobrecargados

111

Aprenda Java public static void probarMetodosSobrecargados() { System.out.printf( "El cuadrado del entero 7 es %d\n", cuadrado(7)); System.out.printf("El cuadrado del doble 7.5 es %f\n", cuadrado(7.5)); // cuadrado(7.5F); //7.5F -> 7.5D } // fin del método probarMetodosSobrecargados public static void main(String[] args) { // invoca al método probarMetodosSobrecargados(); } // fin de main } // fin de la clase Sobrecarga

El programa siguiente, Sobrecarga2.java, es otro programa que utiliza métodos sobrecargados. //Demuestra el uso de los métodos sobrecargados public class Sobrecarga2 { // regresa el mayor entre dos valores int public static int max(int num1, int num2) { if (num1 > num2) return num1; else return num2; } // fin del método max // regresa el mayor entre dos valores double public static double max(double num1, double num2) { if (num1 > num2) return num1; else return num2; } // fin del método max // regresa el mayor de tres números double public static double max(double num1, double num2, double num3){ return (max(max(num1, num2), num3)); } // fin del método max public static void main(String[] args) { // invoca al método max con dos parámetros int System.out.printf("El mayor entre 3 y 4 es " + max(3, 4)); // invoca al método max con dos parámetros double System.out.println("El mayor entre 3.5 y 4.5 es " + max(4.5, 3.5));

112

Aprenda Java

// invoca al método max con tres parámetros double System.out.println("El mayor entre 3.5 y 4.5 y 10.5 es " + max(3.5, 4.5, 10.5)); } // fin del 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, tipos y orden de sus parámetros. El programa siguiente, ErrorSobrecarga.java, ilustra los errores que genera el compilador cuando dos métodos tienen la misma firma, pero distintos valores de retorno. //Muestra cuando sucede un error en la sobrecarga de métodos. public class ErrorSobrecarga { // Este programa no funciona, el compilador marca un error // de sintaxis. // declara un método con un argumento int public int cuadrado(int x) { return x * x; } // fin del método cuadrado public double cuadrado(int x) { return x * x; } // 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. Además, los métodos sobrecargados no necesitan tener el mismo número de parámetros.

6.10. El ámbito de las variables. Una variable local es una variable que es declarada y utilizada localmente dentro de un método. El bloque de una variable se establece por el par de llaves más cercanas que encierran la declaración de la variable. Los parámetros de un método usualmente no se consideran como variables locales, pero son muy similares a éstas en el sentido de que son declaradas y utilizadas localmente dentro del método. 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. El programa siguiente, Alcance.java, ilustra lo mencionado anteriormente.

113

Aprenda Java //Programa que demuestra el ámbito de una variable. public class Alcance { public static void metodoUno() { int x = 5; // x es una variable local int w = 5; // w es otra variable local System.out.println("x = " + x); // la variable i es visible en el ciclo for for (int i = 0; i < x; i++) { System.out.println(i); w = w + 1; // la variable w/x es visible aquí también } // fin for // Esto es un error, la variable i no //existe en este bloque // System.out.println( i ); // manda llamar al método, le pasa como argumento el valor de x metodoDos(x); } // fin del metodoUno private static void metodoDos(int valor) { int x = 5; // variable distinta de la variable x de metodoUno x++; // modifica el valor de la variable local // la variable local es visible en este bloque System.out.println("El parámetro vale: " + valor); // Esto es un error, la variable w no es visible en este bloque // System.out.println( "w = " + w ); } // fin del metodoDos public static void main(String[] args) { metodoUno(); } // fin del método main } // fin de la clase Alcance

114

Aprenda Java

6.11. Ejercicios resueltos. 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. Nota: los problemas que se resuelven aquí no tienen una solución única. Problema 1. Escribe un programa controlado por menú que permita calcular el área de un triangulo, cuadrado, circulo y rectángulo. El programa deberá utilizar métodos void y con valores de retorno. //Programa para practicar métodos. import java.util.Scanner; //para leer del teclado public class FigurasGeometricas { private static double areaTriangulo(double base, double altura) { return base * altura / 2.0; } // fin del método areaTriangulo private static double areaCuadrado(double lado) { return lado * lado; } // fin del método areaCuadrado private static double areaCirculo(double radio) { return Math.PI * radio * radio; } // fin del método areaCirculo private static double areaRectangulo(double base, double altura){ return base * altura; } // fin del método areaRectangulo private static void mostrarTitulo() { System.out.println("Areas figuras geométricas."); System.out.println("--------------------------"); } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System.out.println("Figuras:"); System.out.println("1. Triángulo."); System.out.println("2. Cuadrado."); System.out.println("3. Rectángulo."); System.out.println("4. Círculo."); System.out.print("Selecciona una opción (1-4): ");

115

Aprenda Java } // fin del método menuOpciones // el menú del programa private static void menu() { // variable local Scanner entrada = new Scanner(System.in); // muestra el título del menú mostrarTitulo(); // muestra las opciones del menú menuOpciones(); // lee la opción del teclado int opcion = entrada.nextInt(); switch (opcion) { case 1: System.out.println("1. Área triángulo."); System.out.println("------------------"); calcularAreaTriangulo(); break; case 2: System.out.println("2. Área cuadrado."); System.out.println("-----------------"); calcularAreaCuadrado(); break; case 3: System.out.println("3. Área rectángulo."); System.out.println("-------------------"); calcularAreaRectangulo(); break; case 4: System.out.println("4. Área círculo."); System.out.println("----------------"); calcularAreaCirculo(); break; default: System.out.println("Opción del menú inválida."); } // fin switch } // fin del método menu private static void calcularAreaTriangulo() { Scanner entrada = new Scanner(System.in); System.out.print("Base? "); double base = entrada.nextDouble(); System.out.print("Altura? ");

116

Aprenda Java double altura = entrada.nextDouble(); double area = areaTriangulo(base, altura); System.out.printf("El área es %.2f%n", area); } // fin del método calcularAreaTriangulo private static void calcularAreaCuadrado() { Scanner entrada = new Scanner(System.in); System.out.print("Lado? "); double lado = entrada.nextDouble(); double area = areaCuadrado(lado); System.out.printf("El área es %.2f", area); } // fin del método calcularAreaCuadrado private static void calcularAreaRectangulo() { Scanner entrada = new Scanner(System.in); System.out.print("Base? "); double base = entrada.nextDouble(); System.out.print("Altura? "); double altura = entrada.nextDouble(); double area = areaRectangulo(base, altura); System.out.printf("El área es %.2f", area); } // fin del método calcularAreaRectangulo private static void calcularAreaCirculo() { Scanner entrada = new Scanner(System.in); System.out.print("Radio? "); double radio = entrada.nextDouble(); double area = areaCirculo(radio); System.out.printf("El área es %.2f", area); } // fin del método calcularAreaCirculo public static void main(String[] args) { String opcion = null; Scanner entrada = new Scanner(System.in);

117

Aprenda Java do {

menu(); System.out.print("\nDeseas continuar? (S/N)"); opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s")); System.out.println(">Fin del programa..."); } // fin del metodo main } // fin de la clase FigurasGeometricas

Problema 2. Escribir un programa controlado por menú para practicar sumas, restas, multiplicaciones y divisiones. //Programa para practicar las operaciones aritméticas básicas. import java.util.Scanner; public class Aritmetica { public static void main(String[] args) { String opcion = null; Scanner entrada = new Scanner(System.in); do {

menu(); System.out.print("\nDeseas continuar? (S/N)"); opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s")); System.out.println(">Fin del programa..."); } // fin del metodo main private static void mostrarTitulo() { System.out.println("Programa aritmética 1.0."); System.out.println("------------------------"); } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System.out.println("Operaciones:"); System.out.println("1. Sumar."); System.out.println("2. Restar."); System.out.println("3. Multiplicar."); System.out.println("4. Dividir."); System.out.print("Selecciona una opción (1-4): "); } // fin del método menuOpciones

118

Aprenda Java // el menú del programa private static void menu() { // variable local Scanner entrada = new Scanner(System.in); // muestra el título del menú mostrarTitulo(); // muestra las opciones del menú menuOpciones(); // lee la opción del teclado int opcion = entrada.nextInt(); switch (opcion) { case 1: System.out.println("1. Practicar sumas."); System.out.println("-------------------"); practicarSuma(); break; case 2: System.out.println("2. Practicar restas."); System.out.println("--------------------"); practicarResta(); break; case 3: System.out.println("3. Practicar multiplicaciones."); System.out.println("------------------------------"); practicarMultiplicacion(); break; case 4: System.out.println("4. Practicar divisiones."); System.out.println("------------------------"); practicarDivision(); break; default: System.out.println("Opción del menú inválida."); } // fin switch } // fin del método menu private static void practicarSuma() { final int NUMERO_PREGUNTAS = 10; // número máximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) {

119

Aprenda Java // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1); // muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " + " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 + numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(numero1 + " + " + numero2 + " = " + (numero1 + numero2)); } // fin else contador++; // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " + " + numero2 + " = " + respuesta + ((numero1 + numero2 == respuesta) ? " correcto" : " incorrecto"); } // fin while System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del método practicarSuma private static void practicarResta() { final int NUMERO_PREGUNTAS = 10; // número máximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1);

120

Aprenda Java

// si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1; numero1 = numero2; numero2 = temp; } // fin if // muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " - " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 - numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(numero1 + " - " + numero2 + " = " + (numero1 - numero2)); } // fin else contador++; // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " - " + numero2 + " = " + respuesta + ((numero1 - numero2 == respuesta) ? " correcto" : " incorrecto"); } // fin while System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del método practicarResta private static void practicarMultiplicacion() { final int NUMERO_PREGUNTAS = 10; // número máximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.in);

121

Aprenda Java while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 9 + 1); int numero2 = (int) (Math.random() * 9 + 1); // muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " * " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 * numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(numero1 + " * " + numero2 + " = " + (numero1 * numero2)); } // fin else contador++; // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " * " + numero2 + " = " + respuesta + ((numero1 * numero2 == respuesta) ? " correcto" : " incorrecto"); } // fin while System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del método practicarMultiplicacion private static void practicarDivision() { final int NUMERO_PREGUNTAS = 10; // número máximo de preguntas int aciertos = 0; // contador de preguntas correctas int contador = 0; // contador de preguntas String reporte = ""; // el reporte inicialmente está vacío Scanner entrada = new Scanner(System.in); while (contador < NUMERO_PREGUNTAS) { // genera dos números aleatorios con el método random int numero1 = (int) (Math.random() * 9 + 1);

122

Aprenda Java int numero2 = (int) (Math.random() * 9 + 1); // si numero1 < numero2 intercambia los valores if (numero1 < numero2) { int temp = numero1; numero1 = numero2; numero2 = temp; } // fin if // muestra la pregunta al usuario System.out.print( "¿Cuánto es " + numero1 + " / " + numero2 + " ? "); int respuesta = entrada.nextInt(); // compara la respuesta if (numero1 / numero2 == respuesta) { System.out.println("La respuesta es correcta."); aciertos++; } // fin if else { System.out.println("La respuesta es incorrecta."); System.out.println(numero1 + " / " + numero2 + " = " + (numero1 - numero2)); } // fin else contador++; // incrementa el contador // genera el reporte reporte += "\n" + numero1 + " / " + numero2 + " = " + respuesta + ((numero1 / numero2 == respuesta) ? " correcto" : " incorrecto"); } // fin while System.out.println("\nRespuestas correctas: " + aciertos + "\n" + reporte); } // fin del método practicarDivision } // fin de la clase Aritmetica

123

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

Aprenda Java System.out.println("miArreglo[2] = " + miArreglo[2]); System.out.println("miArreglo[3] = " + miArreglo[3]); //esto es un error //int[] lista; //lista = {1,2,3,4,5}; } // fin del método main } // fin de la clase DatosArreglo

El inicializador de un arreglo unidimensional no requiere utilizar la palabra clave new. Cuando el compilador encuentra la declaración de un arreglo unidimensional que incluya una lista inicializadora, cuenta el número de inicializadores en la lista para determinar el tamaño del arreglo unidimensional, y después establece la operación new apropiada.

7.2. Operaciones básicas con arreglos unidimensionales. Los programas siguientes muestran como inicializar un arreglo unidimensional y algunas operaciones básicas para manipular esos arreglos. El programa siguiente, LecturaArreglo.java valores leídos desde el teclado.

inicializa un arreglo unidimensional con

//Inicializar los valores de un arreglo. import java.util.Scanner; //para leer del teclado public class LecturaArreglo { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); int[] miArreglo; System.out.print("Introduce el tamaño del arreglo? "); int tamaño = entrada.nextInt(); // crea el arreglo miArreglo = new int[tamaño]; // lee los valores del teclado System.out.println("Lectura de los datos del arreglo."); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("Valor[%d]? ", i); miArreglo[i] = entrada.nextInt(); } // fin for // imprime el contenido del arreglo System.out.println("\nEl contenido del arreglo:"); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("miArreglo[%d] = %d\n",

127

Aprenda Java i, miArreglo[i]); } // fin for } // fin del método main } // fin de la clase LecturaArreglo

El programa siguiente, ArregloAleatorio.java inicializa un arreglo unidimensional con valores aleatorios utilizando el método Math.random. //Inicializar los valores de un arreglo. public class ArregloAleatorio { public static void main(String[] args) { double[] miArreglo = new double[10]; // inicializa el arreglo con valores aleatorios for (int i = 0; i < miArreglo.length; i++) { // 0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random() * 100; } // fin for // imprime el contenido del arreglo System.out.println("El contenido del arreglo:"); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("miArreglo[%d] = %.2f\n", i, miArreglo[i]); } // fin for } // fin del método main } // fin de la clase ArregloAleatorio

El programa siguiente, unidimensional.

SumaArreglo.java

suma

los

elementos

de

un

//Sumar los valores de un arreglo. public class SumaArreglo { public static void main(String[] args) { double[] miArreglo = new double[10]; double suma = 0.0; // inicializa el arreglo con valores aleatorios for (int i = 0; i < miArreglo.length; i++) { // 0.0 hasta 100 sin incluirlo miArreglo[i] = Math.random() * 100; // va sumando los valores del arreglo suma += miArreglo[i]; // suma = suma + miArreglo[i]; } // fin for // imprime la suma del arreglo

128

arreglo

Aprenda Java System.out.printf("La suma de los valores del arreglo es %.2f", suma); } // fin del método main } // fin de la clase SumaArreglo

El programa siguiente, MayorArreglo.java encuentra el elemento mayor de un arreglo unidimensional. //Encuentra el elemento mayor de un arreglo. public class MayorArreglo { public static void main(String[] args) { double[] miArreglo = { 1.9, 2.9, 1.8, 3.4, 2.2 }; double mayor = miArreglo[0]; // asume que es el mayor // procesa el arreglo, iniciando en el indice 1 for (int i = 1; i < miArreglo.length; i++) { if (miArreglo[i] > mayor) mayor = miArreglo[i]; } // fin for // imprime la suma del arreglo System.out.printf("El elemento mayor es %.2f", mayor); } // fin del método main } // fin de la clase MayorArreglo

El programa siguiente, IntercambioAleatorio.java, utiliza el método Math.random para intercambiar aleatoriamente los elementos del arreglo unidimensional. //Intercambia aleatoriamente los valores del arreglo. public class IntercambioAleatorio { public static void main(String[] args) { int[] miArreglo = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // procesa el arreglo for (int i = 0; i < miArreglo.length; i++) { // genera el indice j aleatoriamente int j = (int) (Math.random() * miArreglo.length); // intercambia int temporal = miArreglo[i] = miArreglo[j] = } // fin for

miArreglo[i] con miArreglo[j]; miArreglo[i]; miArreglo[j]; temporal;

// imprime los valores del arreglo

129

Aprenda Java System.out.println("Los valores del arreglo:"); for (int i = 0; i < miArreglo.length; i++) { System.out.print(miArreglo[i] + " "); } // fin for } // fin del método main } // fin de la clase Shuffling

El programa siguiente, ForEach.java utiliza la instrucción for mejorada para procesar arreglos unidimensionales. //Instrucción for mejorada. public class ForEach { public static void main(String[] args) { int[] miArreglo = { 1, 5, 3, 4, 7, 9 }; // procesa el arreglo for (int elemento : miArreglo) System.out.println(elemento); } // fin del método main } // fin de la clase ForEach

La instrucción for mejorada, itera a través de los elementos o colección sin utilizar un contador. El programa siguiente, CopiarArreglo.java, copia el contenido de un arreglo unidimensional en otro utilizando un ciclo for tradicional y usa un for mejorado para listar los elementos del arreglo copiado. //Programa que copia un arreglo en otro. public class CopiarArreglo { public static void main(String[] args) { int[] lista = { 1, 2, 3, 4, 5 }; // creamos el arreglo int[] copia = new int[lista.length]; // copiamos uno a uno cada elemento for (int i = 0; i < lista.length; i++) copia[i] = lista[i]; // imprimimos el contenido de copia for (int elemento : copia) System.out.print(elemento + " "); } // fin del método main } // fin de la clase CopiarArreglo

130

Aprenda Java

7.3. Paso de arreglos unidimensionales a los métodos. Para pasar un argumento tipo arreglo unidimensional a un método se específica el nombre del arreglo unidimensional sin corchetes. El programa siguiente, PasoArreglo.java utiliza un método que recibe como argumento un arreglo unidimensional de tipo double. //Paso de arreglos a los métodos. public class PasoArreglo { public static void main(String[] args) { double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 }; double[] y = { 11.4, 31.7, 13.4, 12.8, 21.8 };

imprimir(x); imprimir(y); // usando un arreglo anónimo imprimir(new double[] { 11.0, 12.0, 13.0, 14.0, 15.0 }); } // fin del método main public static void imprimir(double[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del método imprimir } // fin de la clase PasoArreglo

Veamos otro ejemplo, pero ahora utilizando el concepto de métodos sobrecargados. El programa siguiente, PasoArreglo2.java, demuestra el uso de métodos sobrecargados. //Paso de arreglos a los métodos. public class PasoArreglo2 { public static void main(String[] args) { double[] x = { 12.0, 34.0, 43.4, 12.0, 23.4 }; int[] y = { 11, 31, 13, 12, 21 };

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

131

Aprenda Java public static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del método imprimir } // fin de la clase PasoArreglo2

7.4. Arreglos unidimensionales como valor de retorno. Al igual que cualquier otro tipo de dato podemos especificar que un método retorne un arreglo unidimensional. El programa siguiente, ProductoVector.java, retorna un arreglo en la llamada de un método. //Calcula el producto de dos arreglos A y B. import java.util.Scanner; //para leer del teclado public class ProductoVector { // variable de clase - variable static private static final int MAX = 10; // tamaño del arreglo public static void main(String[] args) { // entrada System.out.println("Arreglo 1."); int[] a = leerArreglo(); System.out.println("Arreglo 2."); int[] b = leerArreglo(); // proceso int producto = productoVectores(a, b); // salida System.out.printf("El producto de AxB = %d", producto); } // fin del método main private static int[] leerArreglo() { // crea el objeto de lectura Scanner entrada = new Scanner(System.in); int[] temp = new int[MAX]; for (int i = 0; i < temp.length; i++) { System.out.printf("Valor[%d]? ",i); temp[i] = entrada.nextInt(); } // fin for return temp; } // fin del método leerArreglo private static int productoVectores(int[] a, int[] b) { int producto = 0;

132

Aprenda Java for (int i = 0; i < MAX; i++) producto = producto + (a[i] * b[i]); return producto; } // fin del método productoVectores } // fin de la clase ProductoVectores

7.5. Lista de argumentos de longitud variable. Con las listas de argumentos de longitud variable podemos crear métodos que reciben un número arbitrario de argumentos. Un tipo de argumentos que va precedido por una elipsis (...) 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. Este uso de la elipsis puede ocurrir sólo una vez en una lista de parámetros, y la elipsis, junto con su tipo, debe colocarse al final de la lista. El programa siguiente, VarArgs.java utiliza un método con lista de argumentos de longitud variable. //Uso de listas de argumentos de longitud variable. public class VarArgs { // calcula el promedio public static double promedio(double... numeros) { double total = 0.0; // inicializa el total // calcula el total usando la instrucción for mejorada for (double d : numeros) total = total + d; return total / numeros.length; } // fin del método promedio public static void main(String args[]) { double d1 = 10.0; double d2 = 20.0; double d3 = 30.0; double d4 = 40.0; System.out.println("Valores iniciales."); System.out.println("------------------"); System.out.printf("d1 = %.2f%n", d1); System.out.printf("d2 = %.2f%n", d2); System.out.printf("d3 = %.2f%n", d3); System.out.printf("d4 = %.2f%n", d4); System.out.println(); System.out.printf("El promedio de d1 y d2 es %.2f%n", promedio(d1, d2));

133

Aprenda Java

System.out.printf("El promedio de d1, d2, d3 y d4 promedio(d1, d2, d3, d4)); } // fin del método main } // fin de la clase VarArgs

es %.2f%n",

7.6. La clase Arrays. La clase Arrays está definida en el paquete java.util e incluye una serie de métodos para manipular arreglos unidimensionales. El programa siguiente, OrdenaArreglo.java utiliza el método Arrays.sort para ordenar un arreglo unidimensional. //Ordena un arreglo con Arrays.sort import java.util.Arrays; public class OrdenaArreglo { public static void main(String[] args) { double[] listaUno = { 6.0, 4.4, -3.3, 2.9, 3.5 }; double[] listaDos = { 4.3, -9.9, 5.5, -2.3, 1.1 }; // ordena el arreglo en orden ascedente Arrays.sort(listaUno); imprimir(listaUno); // ordena el arreglo en forma selectiva Arrays.sort(listaDos, 1, 4); imprimir(listaDos); } // fin del método main private static void imprimir(double[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del método imprimir } // fin de la clase OrdenaArreglo

El programa siguiente, BusquedaArreglo.java utiliza el método Arrays.binarySearch para buscar un elemento en un arreglo unidimensional. //Busca en un arreglo utilizando Arrays.binarySearch. import java.util.Arrays; public class BusquedaArreglo { public static void main(String[] args) { int[] miArreglo = { 7, 9, 1, 2, 4, 5, 8, 6};

134

Aprenda Java

//ordena el arreglo Arrays.sort( miArreglo ); //imprime el arreglo imprimir( miArreglo );

}

}

//busca algunos valores System.out.printf( "El valor %d se 1, Arrays.binarySearch( System.out.printf( "El valor %d se 5, Arrays.binarySearch( System.out.printf( "El valor %d se 3, Arrays.binarySearch( //fin del método main

encuentra en la pos %d%n", miArreglo, 1)); encuentra en la pos %d%n", miArreglo, 5)); encuentra en la pos %d%n", miArreglo, 3));

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

El programa siguiente, ComparaArreglos.java, compara arreglos con el método Arrays.equals. //Compara si dos arreglos son iguales con el método Arrays.equals import java.util.Arrays; public class ComparaArreglos { public static void main(String[] args) { int[] califJava = { 100, 80, 70, 50, 10}; int[] califNet = { 100, 80, 70, 50, 10}; int[] califVB = { 100, 87, 75, 35, 19};

}

System.out.println( Arrays.equals(califJava, califNet)); System.out.println( Arrays.equals(califJava, califVB)); } //fin del método main //fin de la clase ComparaArreglos

El programa siguiente, RellenarArreglo.java utiliza el método Arrays.fill para llenar el contenido del arreglo con un valor específico. //Utiliza el método Arrays.fill. public class RellenarArreglo { public static void main(String[] args) { int[] listaJava = new int[5]; int[] listaNet = { 1, 2, 3, 4, 5 };

135

Aprenda Java

// llena de 9 el arreglo Arrays.fill(listaJava, 9); // llena de 9 una parte de la lista Arrays.fill(listaNet, 0, 2, 9);

imprimir(listaJava); imprimir(listaNet); } // fin del método main private static void imprimir(int[] arreglo) { for (int i = 0; i < arreglo.length; i++) System.out.print(arreglo[i] + " "); System.out.println(); } // fin del método imprimir } // fin de la clase RellenarArreglo Conceptos clave: método fill de la clase Arrays.

El programa siguiente, CopiarArreglo2.java, utiliza el método System.arraycopy para copiar el contenido de un arreglo en otro. //Utiliza el método System.arrayCopy. public class CopiarArreglo2 { public static void main(String[] args) { int[] listaJava = new int[5]; int[] listaNet = { 1, 2, 3, 4, 5 };

}

}

// copia el contenido del arreglo System.arraycopy(listaNet, 0, listaJava, 0, listaJava.length); imprimir(listaJava); //fin del método main

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

136

Aprenda Java

7.7. Ejercicios resueltos. 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. Nota: los problemas que se resuelven aquí no tienen una solución única. Problema 1. Escribir un programa controlado por menú que utilice las operaciones básicas estudiadas en esta lección. //Programa que implementa las operaciones básicas con //arreglos unidimensionales. import java.util.Arrays; import java.util.Scanner; //para leer del teclado public class ArregloApp { public static void main(String[] args) { final int TAMAÑO_ARREGLO = 10; // el tamaño del arreglo // crea un arreglo de 10 posiciones int[] listaNumero = new int[TAMAÑO_ARREGLO]; String opcion = null; Scanner entrada = new Scanner(System.in); do {

menu(listaNumero); System.out.print("\nDeseas continuar? (S/N)"); opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s")); System.out.println(">Fin del programa..."); } // fin del método main // el titulo del programa private static void mostrarTitulo() { System.out.println("Operaciones básicas con arreglos."); System.out.println("---------------------------------"); } // fin del método mostrarTitulo // las opciones del menú del programa private static void menuOpciones() { System.out.println("1. Leer desde el teclado."); System.out.println("2. Llenar el arreglo aleatoriamente."); System.out.println("3. Imprimir el contenido del arreglo."); System.out.println("4. Encontrar el número mayor."); System.out.println(

137

Aprenda Java "5. Contar las ocurrencias del número mayor."); System.out.println("6. Contar las ocurrencias del cero."); System.out.println("7. Contar las ocurrencias de un número."); System.out.println( "8. Muestra las ocurrencias en el arreglo."); System.out.println("9. Crea un histograma con el arreglo."); System.out.println("Selecciona una opción (1-9): "); } // fin del método menuOpciones // el menu del programa private static void menu(int[] miArreglo) { Scanner entrada = new Scanner(System.in); // muestra el titulo del programa mostrarTitulo(); // muestra las opciones del menu menuOpciones(); // lee la opción del teclado int opcion = entrada.nextInt(); switch (opcion) { case 1: System.out.println("1. Leer desde el teclado."); System.out.println("-------------------------"); leerArreglo(miArreglo); break; case 2: System.out.println( "2. Llenar el arreglo aleatoriamente."); System.out.println( "------------------------------------"); datosAleatorios(miArreglo); break; case 3: System.out.println( "3. Imprimir el contenido del arreglo."); System.out.println( "-------------------------------------"); imprimirArreglo(miArreglo); break; case 4: System.out.println("4. Encontrar el número mayor."); System.out.println("-----------------------------"); mostrarMayor(miArreglo); break; case 5: System.out.println(

138

Aprenda Java "5. Contar las ocurrencias del número mayor."); System.out.println( "-------------------------------------------"); mostrarOcurrenciaMayor(miArreglo); break; case 6: System.out.println("6. Contar las ocurrencias del cero."); System.out.println("-----------------------------------"); mostrarOcurrenciaCeros(miArreglo); break; case 7: System.out.println( "7. Contar las ocurrencias de un número."); System.out.println( "---------------------------------------"); // el número podría leerse desde el teclado // aquí se genera aleatoriamente. mostrarRepeticiones(miArreglo, (int) (Math.random() * 10)); break; case 8: System.out.println( "8. Muestra las ocurrencias en el arreglo."); System.out.println( "-----------------------------------------"); mostrarRepeticiones(miArreglo); break; case 9: System.out.println( "9. Crea un histograma con el arreglo."); System.out.println( "-------------------------------------"); histograma(miArreglo); break; default: System.out.println("Opción del menú inválida."); } // fin switch } // fin del método menu private static void leerArreglo(int[] miArreglo) { Scanner entrada = new Scanner(System.in); System.out.printf("Introduce %d números enteros (0-9).%n", miArreglo.length); for (int i = 0; i < miArreglo.length; i++) { System.out.printf("Valor %d ?", i + 1); miArreglo[i] = entrada.nextInt(); } // fin for

139

Aprenda Java imprimirArreglo(miArreglo); } // fin del método leerArreglo private static void imprimirArreglo(int[] miArreglo) { System.out.println("Contenido del arreglo."); for (int item : miArreglo) System.out.printf("%d\t", item); System.out.println(); } // fin del método imprimirArreglo private static void datosAleatorios(int[] miArreglo) { System.out.println( "Generando datos aleatorios para el arreglo."); for (int i = 0; i < miArreglo.length; i++) miArreglo[i] = (int) (Math.random() * 10); imprimirArreglo(miArreglo); } // fin del método datosAleatorios // determina el mayor número del arreglo. private static int obtenerMayor(int[] miArreglo) { int mayor = miArreglo[0]; // asume que es el mayor for (int i = 1; i < miArreglo.length; i++) { if (miArreglo[i] > mayor) mayor = miArreglo[i]; } // fin for return mayor; } // fin del método numeroMayor // cuenta las ocurrencias del número mayor private static int ocurrenciaMayor(int[] miArreglo) { int mayor = obtenerMayor(miArreglo); int contador = 0; for (int i = 0; i < miArreglo.length; i++) { if (miArreglo[i] == mayor) contador++; } // fin for return contador; } // fin del método ocurrenciaMayor // cuenta los elementos que son cero private static int cuentaCeros(int[] miArreglo) { int contador = 0; for (int i = 0; i < miArreglo.length; i++) { if (miArreglo[i] == 0)

140

Aprenda Java contador++; } // fin for return contador; } // fin del método cuentaCeros // muestra las ocurrencias de un determinado número private static int cuentaRepeticiones(int[] miArreglo, int numero) { int contador = 0; for (int i = 0; i < miArreglo.length; i++) { if (miArreglo[i] == numero) contador++; } // fin for return contador; } // fin del método cuentaRepeticiones // imprime un histograma de frecuencia private static void histograma(int[] miArreglo) { System.out.println(); for (int i = 0; i < miArreglo.length; i++) { // imprime el histograma para ese num System.out.printf("%d : ", miArreglo[i]); for (int j = 0; j < miArreglo[i]; j++) { System.out.print("*"); } // fin for System.out.println(); } // fin for } // fin del 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.length]; // copiamos el contenido del arreglo original a temporal System.arraycopy(miArreglo, 0, temporal, 0, temporal.length); // ordenamos el arreglo Arrays.sort(temporal); // empezamos a contar las ocurrencias System.out.println(); int contador = 1; for (int i = 0; i < temporal.length; i++) { for (int j = 0; j < temporal.length; j++) { if (temporal[i] == temporal[j] && i != j) { temporal[j] = -1;

141

Aprenda Java contador++; } // fin if } // fin for // imprime el reporte if (temporal[i] != -1) System.out.printf( "%d se repite %d veces%n", temporal[i], contador); contador = 1; // inicializa para volver a contar } // fin for } // fin del método mostrarRepeticiones private static void mostrarRepeticiones(int[] miArreglo, int numero) { System.out.printf( "El número %d se repite %d veces.%n", numero, cuentaRepeticiones(miArreglo, numero)); } // fin del método mostrarRepeticiones private static void mostrarOcurrenciaCeros(int[] miArreglo) { System.out.printf("El 0 se repite %d veces%n", cuentaCeros(miArreglo)); } // fin del método mostrarOcurrenciaCeros private static void mostrarOcurrenciaMayor(int[] miArreglo) { System.out.printf("El %d se repite %d veces%n", obtenerMayor(miArreglo), ocurrenciaMayor(miArreglo)); } // fin del método mostrarOcurrenciaMayorMenor private static void mostrarMayor(int[] miArreglo) { System.out.printf("El mayor del arreglo es %d%n", obtenerMayor(miArreglo)); } // fin del método mostrarMayorMenor } // fin de la clase ArregloApp

142

Aprenda Java

8. Arreglos bidimensionales. Al finalizar esta lección, serás capaz de: •

Utilizar arreglos bidimensionales en los programas Java.

8.1. Declarar, crear y asignar valores a un arreglo bidimensional. Los arreglos bidimensionales se utilizan para representar tablas de valores, las cuales consisten en información ordenada en filas y columnas. Para identificar un elemento específico de un arreglo bidimensional, debemos especificar dos subíndices. Por convención, el primero identifica la fila del elemento y el segundo su columna. El programa siguiente, DeclararArreglo2D.java declara un arreglo bidimensional de tipo double. //Declara un arreglo de dos dimensiones. public class DeclararArreglo2D { public static void main(String[] args) { double[][] arreglo2D; // otra forma: double arreglo2D[][]; // es un error // double arreglo2D[5][6]; // double arreglo2D(4)(3); } // fin del método main } // fin de la clase DeclararArreglo2D

Los arreglos bidimensionales usan la misma sintaxis básica que los arreglos unidimensionales, excepto por un par segundo par de corchetes ( []). Para declarar y crear un arreglo bidimensional utilizamos el operador new y dos valores literales que representan las filas y columnas respectivamente. El programa siguiente, CrearArreglo2D.java declara y crea dos arreglos bidimensionales de tipo int y double con un tamaño de 10x10 respectivamente. //Declara y crea un arreglo de dos dimensiones. public class CrearArreglo2D { public static void main(String[] args) { double[][] arreglo2D; arreglo2D = new double[10][10]; // versión corta int[][] tabla = new int[10][10]; // esto un error // int tabla[4][5];

143

Aprenda Java // int[4][5] tabla; // int tabla = new tabla[5,5]; } // fin del 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, 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. El programa siguiente, ValoresArreglo2D.java, declara, crea y asigna valores a un arreglo bidimensional de tipo double. //Declara,crea y asigna valores en un arreglo de dos dimensiones. public class ValoresArreglo2D { public static void main(String[] args) { double[][] tabla = new double[3][3]; // // // //

inicializar el arreglo 2D con estos datos 5.6 4.5 3.3 1.2 4.0 3.2 4.0 5.4 9.9

// 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] =

los valores del arreglo 2D renglón x columna 5.6; 4.5; 3.3; 1.2; 4.0; 3.2; 4.0; 5.4; 9.9;

// esto es un error // genera un ArrayIndexOutOfBoundsException // tabla[3][3] = 12.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. Para obtener el número de filas en un arreglo bidimensional utilizamos la expresión arreglo2D.length y la expresión arreglo2D[fila].length determina el número de columnas en la fila actual del arreglo bidimensional. El programa siguiente, DefaultArreglo2D.java, obtiene el tamaño de un arreglo bidimensional así como accede a sus valores por default.

144

Aprenda Java //Tamaño del arreglo y valores por default. public class DefaultArreglo2D { public static void main(String[] args) { double[][] tabla = new double[3][3]; // accede la primera posición del arreglo2D System.out.println("tabla[0][0] = " + tabla[0][0]); // esto es un error, no se puede acceder a un indice más grande // System.out.println( "tabla[0] = " + tabla[5][5] ); // utiliza la propiedad length para obtener el // tamaño del arreglo 2D System.out.println("Tamaño del arreglo 2D = " + tabla.length); System.out.println("Tamaño del renglón = " + tabla[0].length); // esto es un error, no se puede cambiar el // tamaño del arreglo 2D // tabla.length = 20; } // fin del método main } // fin de la clase DefaultArreglo2D

Al igual que los arreglos unidimensionales, los arreglos bidimensionales pueden inicializarse mediante inicializadores de arreglos en las declaraciones. Un arreglo bidimensional de nombre tabla con tres filas y tres columnas podría declararse e inicializarse con inicializadores de arreglos anidados. El programa siguiente, DatosArreglo2D.java, declarar e inicializa un arreglo bidimensional de tipo double. //Declara e inicializa un arreglo de dos dimensiones. public class DatosArreglo2D { public static void main(String[] args) { // no se requiere la palabra clave new double[][] tabla = { { 1.9, 2.9, 3.4 }, { 5.5, 7.2, 3.3 }, { 8.7, 3.4, 9.9 } }; // accede al primer renglón System.out.println("Contenido del System.out.println("tabla[0][0] = System.out.println("tabla[0][1] = System.out.println("tabla[0][2] =

primer renglón:"); " + tabla[0][1]); " + tabla[1][2]); " + tabla[2][3]);

// esto es un error // int[][] lista; // lista = {{1,2,3},{4,5,6},{7,8,9}}; } // fin del método main } // fin de la clase DatosArreglo2D

145

Aprenda Java Los valores del inicializador se agrupan por filas entre llaves. 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, para determinar el número de filas en el arreglo. El compilador cuenta los valores inicializadores en el inicializador de arreglos anidado de una fila, para determinar el número de columnas en esa fila. Esto significa que las filas pueden tener distintas longitudes. El programa siguiente, ArregloDesigual.java declara e inicializa un arreglo con filas de distintas longitudes. //Declara e inicializa un arreglo 2D desigual. public class ArregloDesigual { public static void main(String[] args) { int[][] triangulo = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5 }, { 3, 4, 5 }, { 4, 5 }, { 5 } }; // es equivalente a declarar...se requiere el primer indice int[][] triangulo2 = new int[5][]; triangulo2[0] = new int[5]; triangulo2[1] = new int[4]; triangulo2[2] = new int[3]; triangulo2[3] = new int[2]; triangulo2[4] = new int[1]; } // fin del 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.

8.2. Operaciones básicas con arreglos bidimensionales. 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. El programa siguiente, LecturaArreglo2D.java declara un arreglo bidimensional de tipo int de tamaño 2x3 y utiliza ciclos for anidados para leer los valores desde el teclado. //Inicializa los datos de un arreglo 2D desde el teclado. import java.util.Scanner; public class LecturaArreglo2D { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); // declara un arreglo2d de 2x3 int[][] tabla = new int[2][3];

146

Aprenda Java

System.out.println("Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas."); System.out.println("Introduce números enteros:"); // lectura del arreglo for (int i = 0; i < tabla.length; i++) { for (int j = 0; j < tabla[i].length; j++) { System.out.printf("Valor[%d][%d]? ", i, j); // lee y asigna el valor del teclado tabla[i][j] = entrada.nextInt(); } // fin for } // fin for // imprime el primer renglón System.out.print("El renglón System.out.print(tabla[0][0] System.out.print(tabla[0][1] System.out.print(tabla[0][2] } // fin del método main } // fin de la clase LecturaArreglo2D

1 + + +

= ["); " "); " "); "]");

El programa siguiente, Arreglo2DAleatorio.java, inicializa un arreglo bidimensional con valores aleatorios generados con el método Math.random. //Inicializa un arreglo 2D con valores aleatorios. public class Arreglo2DAleatorio { public static void main(String[] args) { int[][] tabla = new int[2][3]; System.out.println("Arreglo con " + tabla.length + " renglones y " + tabla[0].length + " columnas."); System.out.println("El arreglo 2D tiene valores random."); // inicializa el arreglo 2D for (int i = 0; i < tabla.length; i++) for (int j = 0; j < tabla[i].length; j++) tabla[i][j] = (int) (Math.random() * 100); // imprime el primer renglón System.out.print("El renglón System.out.print(tabla[0][0] System.out.print(tabla[0][1] System.out.print(tabla[0][2] } // fin del método main } // fin de la clase Arreglo2DAleatorio

147

1 + + +

= ["); " "); " "); "]");

Aprenda Java El programa siguiente, ImprimirArreglo2D.java, imprime el contenido del arreglo bidimensional . //Imprime el contenido de un arreglo2D. public class ImprimirArreglo2D { public static void main(String[] args) { // Declara e inicializa un arreglo 2D // de 3 renglones, 3 columnas int[][] tabla = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; System.out.println("Valores del arreglo."); System.out.println("--------------------"); // imprime el contenido del arreglo for (int i = 0; i < tabla.length; i++) { System.out.print("Renglon " + i + " = [ "); for (int j = 0; j < tabla[i].length; j++) System.out.print(tabla[i][j] + " "); System.out.println("]"); } // fin for } // fin del método main } // fin de la clase ImprimirArreglo2D

El programa siguiente, SumaArreglo2D.java suma todos los elementos del arreglo bidimensional. //Suma todos los elementos del arreglo 2D. public class SumaArreglo2D { public static void main(String[] args) { // declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60, 00, 70.00, 80.00, 99.99 } }; System.out.println("Suma los datos del tabulador."); System.out.println("-----------------------------"); double suma = 0.0; for (int i = 0; i < tabulador.length; i++) for (int j = 0; j < tabulador[i].length; j++) suma += tabulador[i][j]; System.out.printf("La suma total es %.2f%n", suma); } // fin del método main } // fin de la clase SumaArreglo2D

148

Aprenda Java El programa siguiente, bidimensional.

SumaColumna2D.java

suma las columnas de un arreglo

//Suma las columnas de un arreglo 2D. public class SumaColumna2D { //Suma las columnas de un arreglo 2D. public class SumaColumna2D { public static void main(String[] args) { // declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60, 00, 70.00, 80.00, 99.99 } }; System.out.println("Suma los datos x columna."); System.out.println("-------------------------"); for (int i = 0; i < tabulador[0].length; i++) { double sumaCol = 0.0; for (int j = 0; j < tabulador.length; j++) sumaCol += tabulador[j][i]; System.out.printf("La suma de la columna %d es %.2f%n", i, sumaCol); } // fin for } // fin del método main } // fin de la clase SumaColumna2D

El programa siguiente, SumaReglon2D.java ,suma los renglones de un arreglo bidimensional y determina cual es renglón con la mayor suma. //Suma los renglones de un arreglo 2D y encuentra el mayor public class SumaRenglon2D { public static void main(String[] args) { // declara e inicializa un arreglo de 4x5 double[][] tabulador = { { 10.50, 12.00, 14.50, 16.75, 18.00 }, { 20.50, 22.28, 24.00, 26.25, 27.50 }, { 34.00, 36.50, 38.00, 40.35, 43.00 }, { 50.00, 60, 00, 70.00, 80.00, 99.99 } }; double renglonMax = 0; // para almacenar la suma del renglón int indiceRenglonMax = 0; // el indice del renglon // obtiene la suma del primer renglón for (int i = 0; i < tabulador[0].length; i++) renglonMax += tabulador[0][i];

149

Aprenda Java

// compara renglonMax con la suma de los otros renglones for (int i = 0; i < tabulador.length; i++) { double sumaRenglon = 0; // suma del 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

Aprenda Java opcion = entrada.next(); } while (opcion.equals("S") || opcion.equals("s")); System.out.println(">Fin del programa..."); } // fin del metodo main // el titulo del programa private static void mostrarTitulo() { System.out.println("Operaciones básicas con arreglos 2D."); System.out.println("------------------------------------"); } // fin del método mostrarTitulo // las opciones del menú private static void menuOpciones() { System.out.println("Operaciones:"); System.out.println("1. Llenar el arreglo 2D."); System.out.println("2. Imprimir el arreglo 2D."); System.out.println( "3. Llenar el arreglo 2D con valores random."); System.out.println("4. Intercambiar valores aleatoriamente."); System.out.println("5. Imprimir la suma total."); System.out.println("6. Imprimir el promedio."); System.out.println("7. Encontrar el elemento mayor."); System.out.println("8. Encontrar el elemento menor."); System.out.print("Selecciona una opción (1-8): "); } // fin del método menuOpciones // el menú del programa private static void menu(int[][] arreglo2D) { // variable local Scanner teclado = new Scanner(System.in); int opcion = 0; // muestra las opciones del menú menuOpciones(); opcion = teclado.nextInt(); switch (opcion) { case 1: System.out.println("1. Llenar el arreglo 2D."); System.out.println("------------------------"); leer(arreglo2D); break; case 2: System.out.println("2. Imprimir el arreglo 2D."); System.out.println("--------------------------"); imprimir(arreglo2D);

153

Aprenda Java break; case 3: System.out.println( "3. Llenar el arreglo con valores random."); System.out.println( "----------------------------------------"); llenarRandom(arreglo2D); break; case 4: System.out.println( "4. Intercambiar valores aleatoriamente."); System.out.println( "---------------------------------------"); shuffling(arreglo2D); break; case 5: System.out.println("5. Imprimir la suma total."); System.out.println("--------------------------"); imprimirSuma(arreglo2D); break; case 6: System.out.println("6. Imprimir el promedio."); System.out.println("------------------------"); imprimirPromedio(arreglo2D); break; case 7: System.out.println("7. Encontrar el elemento mayor."); System.out.println("-------------------------------"); imprimirMaxValor(arreglo2D); break; case 8: System.out.println("8. Encontrar el elemento menor."); System.out.println("-------------------------------"); imprimirMinValor(arreglo2D); break; default: System.out.println("Opción del menú inválida."); } // 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.in); // mensaje de usuario System.out.printf("Introduce los datos de la matriz %d x %d%n",

154

Aprenda Java matriz.length, matriz[0].length); // lectura de la matriz for (int ren = 0; ren < matriz.length; ren++) { for (int col = 0; col < matriz[ren].length; col++) { System.out.printf("Valor[%d][%d]? ", ren, col); matriz[ren][col] = entrada.nextInt(); } // fin for } // fin for } // fin del método leer // imprime el contenido del matriz private static void imprimir(int[][] matriz) { // mensaje de usuario System.out.printf("Matriz de %d x %d.%n", matriz.length, +matriz[0].length); // impresión del matriz for (int ren = 0; ren < matriz.length; ren++) { for (int col = 0; col < matriz[ren].length; col++) System.out.printf("[ %d ] ", matriz[ren][col]); System.out.println(); } // fin for } // fin del 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; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) matriz[ren][col] = (int) (Math.random() * 100); System.out.println( "La matriz se ha inicializado con datos random."); imprimir(matriz); } // fin del 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; ren < matriz.length; ren++) { for (int col = 0; col < matriz[ren].length; col++) { // genera indices aleatorios para ren, col int renAux = (int) (Math.random() * matriz.length); int colAux = (int) (Math.random() * matriz[col].length); // intercambia tabla[ren][col]

155

Aprenda Java // por tabla[renAux][colAux] int temp = matriz[ren][col]; matriz[ren][col] = matriz[renAux][colAux]; matriz[renAux][colAux] = temp; } // fin for } // fin for System.out.println( "Los datos de la matriz ya se han intercambiado."); imprimir(matriz); } // fin del método shuffling // suma todos los datos de la matriz private static int suma(int[][] matriz) { int sum = 0; for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) sum = sum + matriz[ren][col]; return sum; } // fin del método calcularSuma // imprime la suma de los datos del matriz private static void imprimirSuma(int[][] matriz) { System.out.printf("La suma de la matriz de %d x %d es %d%n", matriz.length, matriz[0].length, suma(matriz)); } // fin del método imprimir private static double promedio(int[][] matriz) { return (double) suma(matriz) / (matriz.length * matriz[0].length); } // fin del método calcularPromedio // imprime el promedio del total de elementos del matriz private static void imprimirPromedio(int[][] matriz) { System.out.printf( "El promedio de los datos de la matriz de %d x %d es %.2f%n", matriz.length, matriz[0].length, promedio(matriz)); } // fin del método imprimirPromedio private static int maxValor(int[][] matriz) { int max = matriz[0][0]; // asume que es el valor más grande // busca el elemento más grande for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) if (matriz[ren][col] > max) // Busca el num mayor max = matriz[ren][col]; // actualiza max

156

Aprenda Java return max; } // fin del método maxValor // imprimir el elemento más grande del matriz private static void imprimirMaxValor(int[][] matriz) { System.out.printf( "El elemento más grande de la matriz de %d x %d es %d%n", matriz.length, matriz[0].length, maxValor(matriz)); } // fin del método imprimirMaxValor private static int minValor(int[][] matriz) { int min = matriz[0][0]; // asume que es el valor más pequeño // busca el elemento más grande for (int ren = 0; ren < matriz.length; ren++) for (int col = 0; col < matriz[ren].length; col++) if (matriz[ren][col] < min) // Busca el num menor min = matriz[ren][col]; // actualiza min return min; } // fin del método minValor // imprimir el elemento más grande del matriz private static void imprimirMinValor(int[][] matriz) { System.out.printf( "El elemento más pequeño de la matriz de %d x %d es %d%n", matriz.length, matriz[0].length, minValor(matriz)); } // fin del método imprimirMinValor } // fin de la clase Arreglo2DApp

157

Aprenda Java

9. Bibliografía consultada. • • • • • • •

Deitel & Deitel, Como programar en Java, Séptima edición, Pearson Education, México 2008. John Dean & Raymond Dean, Introducción a la programación con Java, Primera edición, McGraw Hill, México 2009. C. Thomas Wu, Programación en Java, Introducción a la programación orientada a objetos, Primera edición, McGraw Hill, México 2008. Bell Douglas & Parr Mike, Java para estudiantes, tercera edicion, Pearson Education, México 2003. Y. Daniel Liang, Java Programming, Comprehensive versión, Eighth Edition , Prentice Hall, New Jersey 2011. Beth Brown , A guide to programming in Java 2 Platform Standard Edition 5, First Edition, Lawrenceville Press , USA 2005. Manual de introducción a la algoritmia: http://es.scribd.com/doc/59204592/IntroducciA %C2%B3n-a-la-Algoritmia-1.

158