Aprendiendo JAVA

(1)

Aprenda Java.

ISC Raúl Oramas Bustillos.

roramas@gmail.com

(2)

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.

(3)

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)

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

6. 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

7. 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

8. 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

(5)

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

(6)

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.

(7)

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

(8)

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

(9)

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

//Ejemplo de secuencias de escape.

public class Mensaje {

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

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

(10)

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 {

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

(11)

2. Programas simples.

• 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 (=).

(12)

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.

(13)

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 {

// crea un objeto Scanner para leer desde el teclado Scanner entrada = new Scanner(System.in);

(14)

// 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.

public class Producto {

System.out.println("Programa que multiplica dos números."); System.out.println("---"); // entrada

(15)

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 {

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

(16)

// 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 {

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;

(17)

// 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.

public class Numero234 {

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

(18)

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

(19)

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.

public class AreaTriangulo {

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.

import java.util.Scanner; //para leer del teclado

(20)

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

//Programa que calcula el equivalente de pies a metros.

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

(21)

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

(22)

// 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.

public class CalculadoraSimple {

// Crea objeto Scanner para obtener la entrada del teclado Scanner entrada = new Scanner(System.in);

(23)

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.

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);

(24)

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.

public class SumaDigitos {

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 {

(25)

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 {

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 {

// declaración y asignación de los valores

double calif1 = 10.0, calif2 = 10.0, calif3 = 10.0;

(26)

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 {

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 +=.

(27)

El programa siguiente, IncrementoDecremento.java, utiliza los operadores de incremento/decremento.

//Operadores de incremento/decremento.

public class IncrementoDecremento {

int x = 0, y = 0; x++; // x = x + 1; x--; // x = x - 1;

System.out.println(x); // el valor de x es cero

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

System.out.println("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.

(28)

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

(29)

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.

public class Sueldo {

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

(30)

El programa siguiente, VolumenCilindro.java, calcula el volumen de un cilindro. //Programa que calcula el volumen de un cilindro.

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.

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

(31)

+ 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.

(32)

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 metros equivalen a:\n\n", nMetros); System.out.printf("%.2f centímetros\n", centimetro);

System.out.printf("%.2f pulgadas\n", pulgada); System.out.printf("%.2f pies\n", pie);

System.out.printf("%.2f yardas\n", yarda); } // fin del método main

} // fin de la clase Metro 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.

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;

(33)

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

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

IMC= w

(34)

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.

public class IndiceMasaCorporal {

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:

//Calcula la distancia entre dos puntos.

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

(35)

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.

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

(36)

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:

(37)

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 {

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 en la Tierra: %d\n", edad);

System.out.printf("Edad en Mercurio: %d\n", edadMercurio); System.out.printf("Edad en Venus: %d\n", edadVenus);

System.out.printf("Edad en Júpiter: %d\n", edadJupiter); System.out.printf("Edad en Saturno: %d\n", edadSaturno); } // fin del método main

(38)

Problema 7.

El programa siguiente, HoraSegundos.java, convierte horas, minutos y segundos a segundos.

//Programa que lee una hora, minutos y segundos y calcula //la cantidad de segundos equivalente.

public class HoraSegundos {

final int HORA_SEG = 3600;

final int MIN_SEG = 60; // variables

int hora, minuto, segundo;

int nSegundos;

System.out.println("Convierte hora-min-seg a segundos."); 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

(39)

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

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.

public class Prestamo {

double cantidad, tasaInteres, nAños;

double adeudo;

System.out.println("Calcula el monto de un préstamo."); System.out.println("---"); // entrada

(40)

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.

public class Monedas {

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;

(41)

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

(42)

3. Instrucciones de selección.

• 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 {

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));