Libroparadigma2017 FINAL2 Caratula

1
No está permitida la reproducción total o parcial de esta obra, ni su tratamiento o transmisión por ningún
procedimiento electrónico o mecánico, incluyendo fotocopiado, grabación magnética o cualquier
almacenamiento de información y sistema de recuperación sin autorización de la editorial. Los derechos
son exclusivos de los autores.
© Derechos reservados
ISBN: 978-958-8801-62-9
Reproducido y editado por ELIZCOM S.A.S
www.elizcom.com
ventas@elizcom.com
Cel: (57) 3113349748
Armenia, Quindío
Colombia
Diciembre 2017
2
Lógica de Programación en
Java
Sonia Jaramillo Valbuena

sjaramillo@uniquindio.edu.co
Adscrito al
Programa de Ingeniería de Sistemas y Computación
Facultad de Ingeniería
Universidad del Quindío
Sergio Augusto Cardona Torres

sergio_cardona@uniquindio.edu.co
Adscrito al
Luis Fernando Castro

lufer@uniquindio.edu.co
Adscrito al
3
4
PREFACIO
Este libro ofrece a los lectores un primer acercamiento a los aspectos básicos de programación y lógica de
programación, siguiendo el paradigma de programación estructurada. Este paradigma ofrece mayor claridad a la
hora de crear una aplicación, dado que usa solamente tres estructuras (secuencial, estructuras de decisión y ciclos)
y subrutinas (funciones o métodos). Todos estos conceptos se desarrollan a través de 4 unidades temáticas que
corresponden a los contenidos del primer curso de Programación del Programa de Ingeniería de Sistemas y
Computación de la Universidad del Quindío.
La unidad I, denominada Introducción a la lógica de programación en Java, incluye temáticas tales como: conceptos
básicos de programación y algoritmia, tipos de datos primitivos, tipos de datos por referencia, variables (declaración,
inicialización, nomenclatura), constantes, comentarios, operadores (aritméticos, relacionales y lógicos), casting,
métodos (con/ sin retorno, con/sin parámetros), llamado de métodos y paso de argumentos. Se crean proyectos
completos, haciendo uso del ambiente de desarrollo Eclipse, aunque el lector puede usar cualquier otro IDE para
digitar sus aplicaciones. La unidad II, aborda el tema de las estructuras de decisión (condicionales): if y switch. La
tercera unidad aborda la programación iterativa: ciclo condicionado al final (do-while) y ciclos condicionados al inicio
(while, for), además de, contadores y acumuladores. La última unidad, trabaja el tema de arreglos. Allí se describe
como crear, recorrer y manipular estructuras contenedoras unidimensionales de tamaño fijo.
Para el entendimiento de este libro no es necesario contar con conocimientos previos en el área de la programación.
Sin embargo, quien desee trabajar con pseudocódigo y diagrama de flujos, antes de realizar las actividades de este
libro, podrá consultar un anexo presente al final del documento con algunas instrucciones en PSeINT [1]. Esta
herramienta es un pseudolenguaje en idioma castellano que enfatiza en la parte algorítmica.
Si bien es cierto, que en este libro no se aborda la Programación Orientada a Objetos, se toman elementos del
Proyecto Cupi2, de la Universidad de los Andes [2], dado que este se consolida como una solución integral al
problema de enseñar y aprender a programar. Partiendo de lo anterior, elementos tales como definición de un
contrato para construir un método, separación de la lógica y la interfaz se utilizan durante todo el libro. El ingreso de
los datos se efectúa mediante cajas de diálogos estándar. Esta lectura no se realiza en los métodos de la lógica,
para que al migrar a la programación orientada a objetos, el estudiante no mezcle los conceptos de lógica e interfaz.
El código construido dentro del libro incorpora el uso de buenas prácticas de programación. Entre ellas se destaca:
usar un único retorno por método, construir métodos cortos (definiendo claramente en el contrato del método),
realizar una codificación legible y entendible por cualquier programador, utilizar llaves en las estructuras de decisión
y ciclos, declarar valores literales como constantes, reutilizar código (modularizar) y usar los patrones de recorrido:
parcial, total y doble recorrido [3].
5
6
Contenido
1. Introducción a la lógica de programación en Java ...................................................................... 11
1.1. Identificadores ......................................................................................................................... 12
1.2 Tipos de datos primitivos ......................................................................................................... 13
1.3 Constantes ................................................................................................................................ 15
1.4 Tipos de datos por referencia................................................................................................... 15
1.5 Expresiones .............................................................................................................................. 18
1.5.1 Operadores aritméticos ...................................................................................................... 18
1.5.1.1 Operadores de incremento y decremento ...................................................................... 18
1.5.1.2 Promoción automática y casting..................................................................................... 26
1.5.2 Operadores lógicos ............................................................................................................ 27
1.5.3 Operadores relacionales .................................................................................................... 28
1.6 Primera interacción con Eclipse............................................................................................... 29
1.7 Métodos ..................................................................................................................................... 36
1.7.1 Documentación del código ................................................................................................ 38
1.7.2 Construcción de programas con métodos ........................................................................ 39
1.7.2.1 Métodos de uso común: leerDouble, leerEntero, leerChar, leerString, leerBoolean e
imprimir ....................................................................................................................................... 40
1.8 Taller de métodos ..................................................................................................................... 45
2. Estructuras de decisión ................................................................................................................. 49
1.1 Instrucción If......................................................................................................................... 49
2.2 Instrucción switch..................................................................................................................... 58
2.3 Taller estructuras de decisión .................................................................................................. 62
3. Estructuras repetitivas ................................................................................................................... 67
3.1 Instrucción for ........................................................................................................................... 67
3.2 Instrucción while ....................................................................................................................... 67
3.3 Instrucción do while ................................................................................................................. 67
3.4 El depurador de Eclipse............................................................................................................ 68
4. Estructuras contenedoras unidimensionales de tamaño fijo ....................................................... 97
4.1 Pila y Stack ................................................................................................................................ 98
4.2 Patrones para instrucciones repetitivas .................................................................................. 98
4.3 Clase Arrays ............................................................................................................................ 100
4.4 Métodos estándar usados en esta unidad: leerArregloEnteros, leerArregloDouble ............ 101
4.5 Taller de arreglos .................................................................................................................... 126
Índice ................................................................................................................................................ 129
Referencias ...................................................................................................................................... 131
7
ANEXO 1. Tabla de códigos UNICODE ............................................................................................ 133
ANEXO 2. PSeInt .............................................................................................................................. 135
ANEXO 3. Instalación de Eclipse ..................................................................................................... 145
8
1. Introducción a la lógica
de programación en Java
Objetivos Pedagógicos
Al final de este nivel el lector estará en capacidad de:
 Comprender y seguir el proceso para resolver un programa de computador haciendo uso

de lenguaje Java.
 Identificar la importancia de los métodos y retornos, a la hora de escribir código reutilizable
y de calidad.
 Crear una solución a un problema haciendo uso de expresiones y métodos. Esto implica,
entre otras acciones, conocer adecuadamente los diferentes tipos de datos y operadores,
comprender la diferencia entre parámetro y argumento e identificar tipos de retorno.
 Escribir documentación
 Utilizar un ambiente de desarrollo para digitar el código fuente y construir la solución del
problema.
9
10
1. Introducción a la lógica de programación en Java
Cuando una empresa requiere una aplicación, lo primero que hace es contactar a un equipo de desarrollo. Este
escucha y analiza las necesidades del cliente, y sigue una serie de etapas (análisis, diseño e implementación) para
poder construir un producto que satisfaga lo solicitado. En la etapa de análisis se determinan los requisitos
funcionales, es decir, lo que se espera que el programa haga, el mundo del problema (contexto en el que se desarrolla
el problema) y los requisitos no funcionales (restricciones tales como hardware, distribución geográfica y factores
humanos). La fase de diseño considera las partes y diferentes relacionales que componen la solución. La fase de
construcción, permite, partiendo del diseño, expresar la solución mediante algoritmos y construir el código fuente.
Un algoritmo es un conjunto de pasos finitos y lógicos para resolver un problema, que consta de pasos estrictamente
descritos y acciones precisas. El archivo que ejecuta el cliente debe pasar por una etapa de pruebas para validar
que si cumpla con los requisitos solicitados inicialmente [2]. La Figura 1 ilustra el proceso seguido:
Figura 1Proceso de solución de un problema, basado en [2]
Dentro de los elementos que forman parte de la solución de un problema, ver Figura 2, se contempla la construcción
de un código fuente (para el caso de este libro, un archivo Java®). Este código luego debe compilarse, para dar lugar
a un archivo de construcción (con extensión .class) que contiene el bytecode o código binario generado acorde a la
arquitectura del equipo. Finalmente, la máquina virtual de java, interpreta el bytecode, para poder desplegar la
aplicación. Es importante, hacer uso de datos de prueba para verificar la validez de los resultados que arroja el
programa. El programador puede valerse de herramientas para automatizar las pruebas de los programas realizados
en Java, tales como JUnit [4].
11
Figura 2 Elementos que forman parte de la solución, tomado de [2]
1.1. Identificadores
Todos los datos e instrucciones de un programa son almacenados en la memoria. Para poder tener acceso a las
diferentes posiciones de memoria, es necesario hacer uso de identificadores. Un identificador es un nombre que
puede darse a una variable, constante (variable con un valor inmutable durante la ejecución de un programa) o a
cualquier otro elemento que necesite nombrarse. Existen diversas reglas para el uso de identificadores:
- Tener en cuenta la sensibilidad al tamaño, es decir, existe distinción entre mayúscula y minúscula, por
ejemplo suma es diferente de sumA.
- No puede contener espacios en blanco. Si se quiere escribir cantidad hijos, se escribiría cantidadHijos.
- Debe iniciar con letra Java (A-Z, a-z, $ y _)
- Puede contener dígitos (0-9).
- Si está formado por más de una palabra, las palabras adicionales iniciarán con mayúscula, cantidadHijos,
edadPromedioPersonas.
- Si es una constante se escribe en maýuscula
- No usar caracteres propios del castellano (tilde, ni la letra ñ) [3].
Ejemplos de identificadores válidos son:
varX PI MAX_NUM dirección
12
1.2 Tipos de datos primitivos
En Java, a cada variable o constante se le debe asociar un tipo de dato. El tipo define el rango de valores que puede
tomar mientras el programa se encuentra en ejecución. Los tipos de datos primitivos permitidos por Java son los
enteros (byte, short, int, long), reales (float, double), tipos de dato caracter (char) y booleanos (boolean).
Los enteros representan un intervalo de los números enteros (sin considerar decimales), ver Tabla 1.
Nombre Rango de valores Tamaño en bits Declaración
byte -128 a 127 8 byte var1=4;
short -32768 a 32767 16 short var2
int -2147483648 a 2147483647 32 int var3;
long -9223372036854775808 a 9223372036854775807 64 long var4;
Tabla 1 Tipos de datos enteros
Algunos ejemplos de variables que tienen naturaleza de tipo entero son: la edad de una persona, la cantidad de
hijos de una persona, la cantidad de equipos en una sala de computadores. Aunque existe 4 diferentes tipos de
datos enteros (byte , short, int y long durante este libro por sencillez solo se utilizará en tipo de dato int.
En Java, cuando se crea una variable de tipo de dato numérico el valor por defecto con el que se inicializa es 0.
El lector debe tener precaución cuando trabaja con lenguajes tales como C++, dado que no ocurre lo mismo. Se
sugiere, por facilidad de migración a otros lenguajes, que cuando declare una variable la inicialice con 0. Para
inicializar una variable se hace uso del operador igual (=), que permite cambiar fijar el valor de la variable al valor
deseado.
Ejemplo:
double promedio=0;
Los reales aceptan rangos de valores con parte entera y decimal, ver Tabla 2. Los datos soportados son float y
double. Para los ejemplos de este libro solo se utiliza tipo de dato double. Este tipo de dato permite desarrollar
completamente los objetivos del curso sin necesidad de estar haciendo conversiones forzosas, lo que le agregaría
mayor dificultad al lector.
Tamaño en
Nombre Rango de valores Declaración
bits
float 3,4E-38 a 3,4E38 32 float num1 = 2.7182f;
double 1.7E-308 a 1.7E308 64 double num2 = 2.125d;
Tabla 2 Tipos de datos reales
13
El tipo de dato caracter, usa la codificación Unicode. Esta codificación permite usar los caracteres de todos los
idiomas. Se caracteriza porque sus primero 127 caracteres corresponden a los mismos caracteres del código ASCII.
Un tipo de dato caracter corresponde a un único carácter. El valor de inicialización debe ir entre comillas simples.
Nombre Rango de valores Tamaño en bits Declaración
char 0 a 65536 (Caracteres alfanuméricos) 16 char letra = 'a';
Tabla 3 Tipo de dato caracter
En Java las variables de tipo char no tienen una inicialización por defecto (contrario a lo que ocurre en C++, que se
inicializa con el carácter nulo), por lo que debe tener la precaución de inicializarla. Tenga en cuenta que a un carácter
se le puede asignar un numero entero (su código ASCII-unicode).
char letra = '0';
char letra = 0;
Las instrucciones:
char letra = 70;

System.out.println(""+letra);
Imprimen:
F
Algunas de las secuencias de escape (caracteres especiales usados con frecuencia), se presentan en la
Tabla 4.
'\n' Salto de línea
'\t' Permite un salto al siguiente tope de tabulación
'\b' Retrocede el cursor en un espacio
'\' Se usa para mostrar el carácter '
'\”' Se usa para escribir una comilla doble (“)
'\'' Se usa para escribir una comilla simple (')
'\\' Se usa para mostrar el carácter back-slash (\)
Tabla 4 Secuencias de escape
Un dato de tipo booleano se caracteriza por tomar únicamente dos valores true o false. Su correcta declaración
e inicialización se muestra en la Tabla 5.
Nombre Rango de valores Declaración e inicialización
boolean true, false boolean bandera = false;
Tabla 5 Tipo de dato boolean
14
1.3 Constantes
Las constantes pueden usarse para dos objetivos: representar valores inmutables o para representar el dominio de
un atributos. La Tabla 6 ilustra cómo se declara una constante.
public final static double PI = 1416; Representan valores inmutables

public final static double IVA = 0.18;
public final static int CARRO = 1;

Representan el dominio de un atributo
public final static int MOTO = 2;
Tabla 6 Descripción uso de constantes
La instrucción final impide que las constantes sean modificadas durante la ejecución del programa.
1.4 Tipos de datos por referencia
Java cuenta con dos tipos de datos: valor y referencia. Cuando se declara una variable que corresponde a un tipo
de dato primitivo, se está haciendo referencia a una variable por valor, que almacena su contenido en una estructura
denominada pila (stack). Los tipos de datos por referencia, corresponden a instancias de clases y utilizan un área de
memoria llamada montículo o heap [5]. Este libro solo hará uso de los tipos de datos por referencia String y las clases
envoltorio. Una clase es una plantilla para crear objeto y un objeto es una instancia de una clase. Las clases
envoltorio permiten manipular un tipo de dato primitivo como un objeto. Los 8 tipos de datos primitivos con su
correspondiente clase envoltorio se muestran en la Tabla 7.
byte - Byte
short - Short
int - Integer
long - Long
float - Float
double - Double
char - Character
boolean - Boolean
Tabla 7 Tipo de dato primitivo con su correspondiente clase envoltorio
El uso de clases envoltorio permite hacer uso de funcionalidades adicionales que fueron implementados en Java en
cada clase, por ejemplo:
15
Clase Screenshot de algunos de los métodos implementados en Java
Integer
La clase Integer encierra un dato primitivo
(tipo int) en un objeto.
Esta clase tiene métodos entre ellos:
convertir un int en un String y un String en
int
Integer dato=new Integer(5);
Double
La clase Double encierra un dato primitivo
(tipo double) en un objeto.
Esta clase tiene métodos entre ellos:
convertir un double en un String y un String
en double
Double dato=new Double(5.0);
Character
Encierra un tipo de dato primitivo de tipo char
Character c=new Character('A');
Tabla 8 Clases envoltorio que se usarán en este libro
La clase String permite expresar un conjunto de caracteres (cadena). Para inicializar una cadena se hace uso de
comillas dobles. Ejemplo
String direccion= "Carrera 12 #23 10";
String nombre= "Maria Jose";
La clase String consta de variados métodos, algunos de ellos, para extracción de caracteres, comparación y
concatenación.
16
Concatenar es unir dos cadenas, en Java esto se logra con el operador +
String direccion= "Carrera 12 #23 10";

String concatenado = dirección + nombre;
A un String se le puede concatenar cualquier tipo de dato primitivo

int edad= 20;
String resultado = nombre + " tiene " + edad + " años ";
Actividad 1. Identificar por cada identificador el tipo de dato correspondiente
1) marca ( ) int
2) capacidadLibras ( ) String
3) modelo ( ) String
4) serie ( ) String
5) tipoProducto ( ) double
6) precio ( ) int
7) isbn ( ) boolean
8) activo ( ) String
17
1.5 Expresiones
Una expresión se compone de variables, constantes y/o operadores.
1.5.1 Operadores aritméticos
Este tipo de operadores permite realizar operaciones. Ellos son: + (suma), - (resta), * (multiplicación), / (división),
% (módulo o residuo de la división entera).
Se debe tener en cuenta que en Java entero dividido entre entero da como resultado otro entero. Por ejemplo:
int a = 20;
int b = 3;
double res = ( a + b ) / 3;
El programa debería imprimir 7.66666666667 pero da 7. Si lo que se desea es conservar estos decimales se pueden
aplicar las siguientes 3 soluciones:
double res = (( a + b )* 1.0) / 3;
double auxiliar = a + b;
double res = auxiliar / 3;
double res = ( a + b ) / 3.0;
1.5.1.1 Operadores de incremento y decremento
Java posee el operador incremental unario ++, y el operador decremental unario --, para incrementar o decrementar
el valor de una variable en 1, respectivamente. La siguiente tabla describe cada uno de estos operadores.
Operadores Significado
x++ Incrementa x después de cualquier operación con ella (post-incremento)
++x Incrementa x antes de cualquier operación con ella (pre-incremento)
x-- Decrementa x después de cualquier operación con ella (post-decremento)
--x Decrementa x antes de cualquier operación con ella (pre-decremento)
Las siguientes expresiones son equivalentes
18
Modo normal Modo con operador
x=x+1; x++;
s=s-1; s--;
Los operadores pueden estar antes o después del operando. Por ejemplo:
s = s+1; es igual a:
++s;
s++;
Hay que tener precaución al usar esos operadores dentro de una expresión. Si operador incremento o decremento
precede a su operando, java realiza operaciones de incremento o decremento antes de usar el valor del operando.
Por el contrario, si el operador está luego del operando, java usa el valor del operador antes de incrementarlo o
decrementarlo.
A continuación, se muestra un ejemplo junto con su equivalencia y resultado final.
Expresión Expresión equivalente Valor final
x = 11; x++; x=11; x = x+1; x = 12;
x = 12; y = ++x; x=12; x = x+1; y = x; y = 13;
x = 10; y = x++; x=10; y = x; x=x+1; y = 10;
x = 10; y = 6 * (++x); x=10; x = x+1; y = 6 *x; y = 66;
x = 10; y = 6 * (x++); x=10; y = 6 *x; x = x+1; y = 60;
Cuando se construyen expresiones es importe tener en consideración, la prioridad de operadores. La prioridad

define el orden en el que se ejecutan las operaciones.
() Paréntesis
+, - Operadores de signo ( PRECAUCION: no hace referencia a suma y resta)
++, --
*, /, %
+, - Suma y resta
<, >, <=, >=, ==, !=
!
&&, ||
=
Tabla 9 Prioridad de operadores
19
Si se tiene una expresión, que contienen operadores con la misma prioridad, Java evalúa la expresión de izquierda
a derecha. Si hay paréntesis lo que está dentro se evalúa primero. Si hay paréntesis internos, lo que está en su
interior se evalúa primero que lo que está en los externos. Ejemplo:
x = (2 + 3) * 8
Por precedencia de operadores, se efectúa primero (2+3) y por último se realiza el producto, por lo tanto:
x = (2 + 3) * 8
x = (5) * 8
x = 40
A continuación se muestra un segundo caso para la evaluación de la expresión.
x = (2+5+5) + (4+1)
Según la precedencia de los operadores, se debe evaluar primero las expresiones con paréntesis, estas son (2+5+5)
y (4+1), en el caso de (3+5+5), como se tiene el mismo operador (+) dentro de la expresión, estos operandos, se
evalúan de izquierda a derecha, por lo tanto la forma en que es evaluada la expresión es:
x = (2+5+5) + (2+1)
x = (7+5) + (3)
x = 12 + 3
x = 15
La siguiente expresión involucra una expresión más compleja:
z = 1 + (10+6*6+7) + (18/2) / 3 / 1 + 2
Inicialmente, se resolverá las expresiones que se encuentran dentro de los paréntesis, se deben resolver las
operaciones que tengan la mayor precedencia.
z = 1 + (10 + 6 * 6 + 1) + (18 / 2) / 3 / 1 + 2
z = 1 + (10 + 36 + 1) + 9 /3 / 1 + 2
Se observa que la expresión (3)/3/1, tiene tres operadores con idéntica precedencia, por lo tanto estos se evalúan
de izquierda a derecha.
20
z = 1 + 47 + 3 + 2
Por lo tanto el valor final de y es z =53
Cuando se tenga una potencia y el exponente involucre una operación ésta debe encerrarse entre paréntesis:
X1/2 = Math.pow (X, 1/2.0)
Recuerde que debe ponerse 2.0 porque 1/2=0, mientras que ½.0=0.5
Si se tiene una raíz esta debe expresarse en forma de potencia. Ejemplo:
n
√4 = Math.pow (4, 1.0/n);
Actividad 2 Realice las siguientes actividades
- Informar el valor faltante:
a) 22 + X = 36 b) 16 – X= 9 c) 11- X = 4 d) X*4 = 38
- Dada la expresión realice el despeje de la x. Recuerde que el operador multiplicación debe reemplazarse por un
asterisco y el división por un slash.
a) 2x + 20 = 2x + 60
b) x + 15 = 17
c) (2x – 4) = x + 7
d) 15x – 10 = (5x – 12)/2
e) 6(x – 6) – 20 = 2(x – 5) – 3
f) 6(x – 2) – 6 (x – 2) = 3(3x – 4)
- Escriba las expresiones para los siguientes problemas
Si se tiene un triángulo equilátero y se sabe su perímetro hallar la longitud de cada lado.
La suma de dos números consecutivos es 60. Informar cuáles son los números.
Actividad 3 Construir expresiones que involucren únicamente los operadores aritméticos y el operador =
1. Construir las expresiones para los siguientes enunciados:
a. Se desea crear una aplicación que permita incrementar el salario de un empleado en un 10%
Variables Expresión
Entrada: salario double salarioIncrementado=salario + salario*0.1

Salida: salarioIncrementado
b. Si se sabe el porcentaje de incremento del salario y el nuevo salario informar cuál era el salario previo
21
Entrada:
Salida:
c. Si se sabe el salario incrementado y el salario anterior informar cual fue el porcentaje de incremento.
Entrada:
Salida:
2. Construir las expresiones referentes al tetraedro.
a. Si se sabe el volumen de un tetraedro regular, calcular el lado. Recuerde que el volumen del tetraedro =
Entrada: a double tetraedro=(Math.sqrt(2) * Math.pow(a, 3))/12;

Salida: tetraedro
b. Si se sabe el volumen calcular a.
Entrada:
Salida:
3. Construir las expresiones referentes a la Esfera.

a. Si se sabe el volumen de una esfera calcular el radio. Recuerde que volumenEsfera = 4/3 𝞹 r3
Entrada:
Salida:
b. Si se sabe el radio calcular el volumen de la esfera
Entrada:
Salida:
22
4. Una finca tiene la siguiente forma, hallar el perímetro de toda la finca y el área, si se conocen las longitudes que
se encuentran punteadas.
a
lado2
lado1
Tenga en cuenta que debe usar Pitágoras.
lado2
lado1
Variables Expresión perímetro de la finca
Entrada:
Salida:
Variables Expresión área de la finca
Entrada:
Salida:
5. Calcular el área de la casa si se conocen las longitudes punteadas
lado3 lado4
lado2
lado1
23
Variables Expresión área de la casa
Entrada:
Salida:
6. Sectores y segmentos de círculos
a. Se tiene una torta de torta de forma circular, de radio r. Si el usuario se come una porción de torta (y se sabe el
ángulo en grados de la porción consumida), informar el área de torta que queda disponible para consumo.
Figura tomada de [6]
Área del sector = ½ × θ × r2
Variables Expresión área del sector
Entrada:
Salida:
b. Resolver este mismo punto si se conoce la longitud de arco de un sector o segmento. Calcular θ.
Longitud de arco = θ × r
Variables Expresión calcular θ
Entrada:
Salida:
8. Escribir una expresión para calcular el área total de la figura 1.
1
Figura basada en http://compumch.webnode.es/a1%C2%B0-primaria-iii-b/actividad-3-19-8-15-herramienta-borrador-
dibujo-figuras-geometricas/
24
Variables Expresión área total de la figura
Entrada:
Salida:
9. Obtener el número de cerámicas cuadradas para cubrir un salón rectangular. El usuario debe ingresar el largo y
ancho del espacio a cubrir, y la longitud de cada cerámica.
Variables Expresión numero ceramicas
Entrada:
Salida:
25
10. Se vende un vehículo perdiendo un porcentaje sobre el precio de compra. Hallar el precio de venta del mismo
si se sabe que costó X pesos.
Variables Expresión precio venta del vehiculo
Entrada:
Salida:
1.5.1.2 Promoción automática y casting
Cuando calcula una expresión que involucre operandos de tipo byte o short, Java efectúa una promoción a int.
También se debe considerar que si hay un operador long, la expresión completa se promociona a este tipo de dato.
Si un operador es float, entonces toda la expresión completa se promociona a float. Igual ocurre si es double. Por
ejemplo si se tiene:
byte a = 10, b = 40, j = 100;
int d = a * b / d;
El resultado de a * b se calcula en entero y no en byte , esto ocurre porque tal operación puede salirse del rango
de los byte. Observe el siguiente ejemplo:
byte b = 2, resultado;
resultado = b * 6; // No se puede efectuar porque un entero no se puede asignar aun byte.
Si se intenta multiplicar un byte b por 6 que es un entero el resultado será un entero, por tal razón este valor no
podría asignarse a un byte. Si se requiere que el resultado se almacene en un byte, será necesario realizar una
conversión explícita (casting):
byte b = 2, resultado;
resultado = (byte)( b * 6 );
26
Actividad 4 Identificar el resultado de expresiones sencillas escritas en Java
1. Dadas las siguientes instrucciones indicar el resultado

int a=5, b=8, c=7;
double d=3;
int resultado= (a*d)-7*b+4/c;
Opciones de respuesta:
a) -40.57 b) -41 c) -36 d) No corre
Dadas las siguientes instrucciones indicar el resultado

int a=5, b=8, c=7;
double d=3;
int resultado=((int) (a*d))-7*b+3/c;
a) -40.57 b) -41 c) -36 d) Ninguna de las anteriores
Dadas las siguientes instrucciones indicar el resultado

int a=5, b=8, c=7;
double d=3;
int resultado=((int) (a*d))-7*b+3%c;
a) -40.57 b) -39 c) -38 d) Ninguna de las anteriores
1.5.2 Operadores lógicos
Estos operadores trabajan sobre operandos de tipo lógico para producir un resultado lógico (false o true). La Tabla
10 presenta los diferentes tipos de operadores lógicos.
Operador Significado
&& AND
|| OR
! NOT
Tabla 10 Operadores lógicos
El operador AND (&&) da como resultado true si los dos operandos son verdaderos. De lo contrario da como
resultado false.
Operando 1 Operador Operando 2 Salida

false && false false
false && true false
true && false false
true && true true
Tabla 11 Operador AND
El operador OR (||) da como resultado verdadero cuando al menos uno de sus operandos es verdadero.
27
Operando 1 Operador Operando 2 Salida
false || false false
false || true true
true || false true
true || true true
Tabla 12 Operador OR
Si la variables está en false, el operador negación cambia el valor de la variable a true. Si está en true lo vuelve
false.
1.5.3 Operadores relacionales
Estos operadores dan como resultado un valor de tipo lógico (true o false). Los operadores lógicos son:
== (igualdad)
!= (diferente)
> (mayor que)
< (menor que)
>= (mayor o igual)
<= (menor o igual)
Tabla 13 operadores relacionales
Actividad 5 Uso de operadores lógicos y relaciones
Escriba las expresiones correspondientes al enunciado:
a) Si es mayor de edad y salario excede 10350000
edad >= 18 && salario > 10350000
b) Si sexo es Masculino y edad es igual a 25.
sexo == 'F' && edad == 25
sexo.equals("femenino") && edad == 25
c) Si número es par y número es divisible por 100.
__________________________________________________________
e) Si celular está encendido y compartir internet está activo.
__________________________________________________________
28
1.6 Primera interacción con Eclipse
Esta práctica le permitirá al lector crear un primer programa. El objetivo es practicar el tema de expresiones, tal
como se muestra en el diagrama de flujo. En primer lugar se crean dos variables a y b, que se inicializan con los
valores de 9 y 6 respectivamente. Luego se halla la raíz cuadrada de cada una de ellas y finalmente se muestran los
resultados.
Para llevar este diagrama a Java, previamente instale Eclipse, tal como se explica en el ANEXO 1. Luego ingrese a
Eclipse y de clic en File -> New Java Project
29
2. De nombre al proyecto y presione Finish
3. De clic derecho sobre el proyecto, elija New-> Class. Dele el nombre de Prueba. Active la opción public static void
main(String[] args) y Generate comments. Luego de clic en Finish
30
4. La siguiente pantalla aparecerá:
31
5. Agregue comentarios para describir la clase
/**
* Programa para utilizar los diferentes operadores aritmeticos vistos en clase
* @param args los argumentos de la línea de comando
*/
El programa debe quedar:
6. Agregue las instrucciones correspondientes, dentro del método main
32
Finalmente, de clic en Ejecutar , para observar los resultados
33
Actividad 6 Crear programas en Java
1. Pase los siguientes diagramas de flujo a Java. Para realizar la lectura de los datos, utilice Scanner
Se debe crear primero una referencia a un objeto de tipo Scanner

Scanner miScanner = new Scanner(System.in);
Para leer un entero:
int num1;
System.out.print("Ingrese un número: ");
Num1 = miScanner.nextInt();
Para leer un double:

double num2;
System.out.print("Ingrese un numero double: ");
num2 = miScanner.nextDouble();
Para leer un String:

String cadena;
System.out.print("Introduzca un string: ");
cadena= miScanner.nextLine();
a. Convertir de metros a centímetros
b. Calcular el nuevo precio de un artículo que se ha incrementado en un 15%
34
2. Escribir expresiones.
Antes de iniciar observe la siguiente nota:
Nota
Si tiene las siguientes instrucciones:
int a=6, b=5;
double resultado=6*5;
System.out.println(a+" * "+b+" = "+resultado);
La salida en la consola será

6 * 5 = 30.0
Crear una aplicación que permita calcular expresiones. Tenga en cuenta que
a=6, b=5, c=2, h=9, x=7, u=3, h=4, y=-22
Restricciones
a, b, c y t son de tipo byte
d, h, w son de tipo entero,
Las demás son de tipo double
35
Actividad 7 Cree una aplicación por cada uno de los puntos de la Actividad 3 un proyecto en Eclipse.
1.7 Métodos
Un método es una subrutina que permite efectuar una tarea particular. Los métodos tienen gran importancia en la
programación estructurada, al brindar la posibilidad de encapsular una serie de instrucciones de manera, que luego
pueden ser invocadas y ejecutadas desde diferentes puntos del programa.
La sintaxis de un método es la siguiente:
public static tipoRetorno nombre( parámetros separados por coma )

{ // Conjunto de instrucciones
}
Los parámetros pueden verse como las variables de entrada, es decir, lo que se requiere para cumplir con la
responsabilidad del método. Es decir, si el método se va a encargar de sumar dos números double, el método tendrá
dos parámetros y tipo de retorno será doublé (porque el resultado de la suma es double).
A la línea correspondiente al encabezado del método (sin el conjunto de instrucciones, es decir, omitiendo lo que
está dentro de las llaves) se le da el nombre de signatura del método [2]. El nombre del método (identificador) debe
iniciar en verbo en infinitivo. Los parámetros se escriben de la siguiente forma: tipo nombre2, tipo nombre2, …
Siempre se debe poner primero el tipo de dato seguido por el nombre del parámetro. Si son varios parámetros se
separan por comas.
public static double calcularSuma( double num1, double num2 )

{
// Conjunto de instrucciones
Cada método debe tener claramente definidos sus compromisos y responsabilidades (es decir, lo que va a hacer)
[2]. No se recomienda la creación de métodos demasiado extensos que “realicen de todo”. En su lugar, deben crearse
múltiples métodos y luego integrarlos. Lo anterior permite obtener un código mejor estructurado y reutilizable,
además de que, facilita la detección de errores.
Recuerde la signatura del método:
public static tipoRetorno nombre( parámetros separados por coma )
Para el caso tipoRetorno, pueden considerarse dos opciones:
1. Sin Retorno (void). Es decir, el método no devuelve ningún valor. Estos métodos son útiles cuando se
pretende modificar el valor de los atributos de una clase [2]. Dado que en este libro no se trata el concepto
de clases y programación orientada a objetos, se evitará su uso y se preferirá el uso de métodos con retorno,
ver Tabla 14.
2. Con retorno: Muchos de los métodos que se utilizan en la vida cotidiana, retornarán valores. Los métodos
pueden retornar valores de tipos primitivos, pueden retornar objetos, pueden retornar arreglos entre otros.
El retorno indica el tipo del resultado por ejemplo en el caso de determinarExistenciaEstudiante el retorno
podría ser booleano, es decir se devolvería un true (si existe) o un false en caso contrario. Si hay retorno
debe especificarse claramente el tipo de dato devuelto y debe incluirse la sentencia return para realizar dicha
tarea.
36
El siguiente gráfico demuestra la importancia de identificar el tipo de retorno adecuado. Observe en primer lugar la
columna 1(SIN RETORNO). Allí se implementa un método sin retorno, llamado calcularSuma, que tiene dos
parámetros double num1 y double num2. El hecho de no tener retorno tiene importantes implicaciones. Para
entender esto, por favor observe el método main, allí el método calcularSuma se invoca 2 veces. La primera vez se
invoca enviándole los valores de 2 y 4, esto daría como resultado 6. La segunda vez, se invoca para sumar 4 y 5,
esto da 9. Si quisiera multiplicar los resultados, 6 más 9, no se puede porque los datos se imprimieron e
inmediatamente se pierden cuando finaliza el método calcularSuma( double num1, double num2 ). El ámbito y tiempo
de vida de las variables está limitado por las llaves, es decir, estas definen cuando su tiempo de vida termina.
Ahora observe la columna, CON RETORNO, y note que dentro del método main el método calcularSuma se invoca
2 veces. La primera vez se invoca enviándole los valores de 2 y 4, esto daría como resultado 6, el valor se retorna y
queda almacenado en resultado1. La segunda vez, se invoca para sumar 4 y 5, esto da 9, el valor se retorna y
queda almacenado en resultado2. A continuación se invoca el método calcularProducto y se le envía como
argumento resultado1 y resultado2, por lo que en la variable resultado 3 se obtendría el valor de 54. Retornar permite
hace que el valor resultante del método pueda ser reutilizado.
SIN RETORNO CON RETORNO

public class Principal { public class Principal {
public static void main(String[] args) { public static void main(String[] args) {
double num1=2; double num1=2;
calcularSuma(num1, num2); double resultado1, resultado2, resultado3;
calcularSuma(num2, num5); resultado1 = calcularSuma(num1, num2);
} resultado2 = calcularSuma(num2, num3);
resultado3 = calcularProducto (resultado1,resultado2);
public static void calcularSuma( double num1, double num2 ) }
{
double res=num1+num2; public static double calcularSuma( double num1, double num2 )
System.out.println("El resultado es"+res); { double res=num1+num2;
} return res;
} }
public static double calcularProducto( double num1, double num2
)
{ double res=num1*num2;
return res;
}
}
Tabla 14 Comparativo método void y con retorno
Se le sugiere al lector, evitar imprimir en los métodos de la lógica. Esta práctica puede verse como una mezcla de
lógica con interfaz y puede traer inconvenientes a la hora de migrar a la Programación orientada a objetos, y
específicamente cuando trabaje paquetes (uno para la lógica y otro para la interfaz gráfica).
Separar la lógica de la interfaz se considera una buena práctica de

programación.
Se debe diferenciar entre los términos parámetro y argumento. Un parámetro es una variable definida por un método
y que recibe un valor cuando se llama a ese método. Un argumento es un valor que se pasa a un método cuando
éste es invocado” 2. Por ejemplo, el método calcularSuma tiene dos parámetros: double num1 y double num2.
Cuando se invoca se le pasan como argumentos los valores de a y b, respectivamente 4 y 7. Observe detenidamente,
parámetro y argumento deben coincidir en tipo, pero no en nombre.
2
Gómez, Carlos Eduardo y Gutierrez, Julián Esteban
37
/**
* Calcula la suma de dos números . <br>
* @param num1 Es el número 1.
* @param num2 Es el segundo número a sumar.
{ double res=num1+num2;
return res;
}
//porción del método main

double a=4;
double b=4;
double res= sumarEnteros( a, b )
1.7.1 Documentación del código
El contrato de un método permite dejar explícitas las condiciones bajo las cuales el método será exitoso, y lo que se
espera del método una vez termine su ejecución. El contrato del método requiere definir las precondiciones y la
postcondición. Las precondiciones (suposiciones o condiciones impuestas por quien desarrolla el método, que
deben ser verdaderas para que el método funciones correctamente). La postcondición es la descripción del resultado
obtenido (compromisos asumidos) luego de la ejecución del método, siempre y cuando no hayan ocurrido
excepciones. Una excepción es un problema inesperado que surge durante la ejecución de un programa. El contrato
es total, esto quiere decir, que ante el incumplimiento de cualquier precondición el método ya no queda obligado a
cumplir la postcondición [2]
Para documentar el contrato de un método se hace uso de Javadoc. Tal como se muestra a continuación:
/**
* Calcula la suma de dos números . <br>
* @param num1 Es el número 1.
* @param num2 Es el segundo número a sumar.
{ double res=num1+num2;
return res;
}
Otros tipos de documentación para explicar un programa son:
- De una sola línea. Se usan dos slash seguidos. Ejemplo:
// se halla el mayor de los dos números
- De varias líneas
/* este programa permite calcular el área de un cuadrado*/
38
1.7.2 Construcción de programas con métodos
Durante todo este documento se hará uso de cuatro importantes métodos: leerDouble, leerEntero, leerChar y
leerString 3. A continuación se presenta el primero de ellos: leerDouble. La explicación presentada es generalizable
para los otros tres métodos.
El método leerDouble permite mediante el uso de una caja de diálogo (JOptionPane), leer un valor de tipo double.
Este método tiene como parámetro un mensaje, que corresponde al mensaje que el usuario visualiza y que le
permitirá entender qué es lo que se le solicita.
/**
* Permite leer un numero double mediante una caja de dialogo
* @param mensaje El mensaje que verá el usuario
* @return el numero ingresado por el usuario
*/
public static double leerDouble (String mensaje)

{
double dato= Double.parseDouble(JOptionPane.showInputDialog(mensaje));
return dato;
}
La línea double dato= Double.parseDouble(JOptionPane.showInputDialog(mensaje)), implica que el usuario verá

una caja de diálogo con el mensaje que se le envíe como argumento cuando se le invoque (por ejemplo: "Ingrese
la base"). Todo lo que se digite en un campo de texto, será considerado como un texto y deberá convertirse al tipo
de dato necesario, para este caso puntual deberá pasarse a doublé. Lo anterior se realiza mediante la instrucción
Double.parseDouble.
Campo de texto
Si se invoca el método, tal como se muestra a continuación:
3
Estos métodos fueron construídos por el ingeniero Julián Esteban Gutiérrez, y se acordó su uso por todos los docentes del
área de Programación y Algoritmia de Ingeniería de Sistemas y Computación de la Universidad del Quindío.
39
/**
* Metodo principal
* @param args Los argumentos de la linea de comando
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String mensaje1= "Ingrese la base";
String mensaje2= "Ingrese la altura";
double base= leerDouble (mensaje1);
double altura= leerDouble (mensaje2);
El usuario visualizará lo siguiente:
1.7.2.1 Métodos de uso común: leerDouble, leerEntero, leerChar, leerString, leerBoolean e imprimir
Los siguientes son métodos de uso común a lo largo del libro.
/**
*/

{
return dato;
}
/**
* Permite leer un numero entero mediante una caja de dialogo
*/
public static int leerEntero (String mensaje)
{
int dato= Integer.parseInt(JOptionPane.showInputDialog(mensaje));
return dato;
}
/**
40
* Permite leer un caracter mediante una caja de dialogo
* @return el caracter ingresado por el usuario
*/
public static char leerChar(String mensaje)
{
char dato= (JOptionPane.showInputDialog(mensaje)).charAt(0);
return dato;
}
/**
* Permite leer una cadena de caracteres mediante una caja de dialogo
* @return el string ingresado por el usuario
*/
public static String leerString (String mensaje)
{
String dato= JOptionPane.showInputDialog(mensaje);
return dato;
}
/**
* Permite leer un boolean
* @param mensaje El mensaje mostrado al usuario
* @return un boolean, true si presiona el boton si, false en caso contrario
*/
public static boolean leerBoolean (String mensaje)
{
boolean centinela=false;
int result = JOptionPane.showConfirmDialog(null,
mensaje,null, JOptionPane.YES_NO_OPTION);
if(result == JOptionPane.YES_OPTION) {
centinela=true;
}
return centinela;
}
/**
* Permite imprimir un mensaje
* @param mensaje El mensaje a imprimir
*/
public static void imprimir (String mensaje)
{
JOptionPane.showMessageDialog(null,mensaje);
}
Ejemplo 1 Calcular el área de un Rectángulo
El siguiente programa permite calcular el área de un Rectángulo, para ello se crea el método calcularArea, que
tiene dos parámetros: base y altura.
41
Programa 1 Hallar el área de un rectángulo
import javax.swing.JOptionPane;
/**
* Clase que representa operaciones sobre un Rectángulo
* @author sonia
* Los métodos leerDouble, leerEntero, leerChar, leerString, leerBoolean e imprimir
* son basados en el material del profesor Julián Esteban Gutierrez de la U.
* del Quindio
*/
public class Rectangulo {
/**
* Metodo principal
*/
double base, altura, area;
String mensaje1= "Ingrese la base";
String mensaje2= "Ingrese la altura";
base= leerDouble (mensaje1);
altura= leerDouble (mensaje2);
area = calcularArea(base, altura);
imprimir ("El area es "+area);
public static double calcularArea(double base, double altura)

{
double area=0;
area= base * altura;
return area;
}
/**
*/

{
return dato;
}
/**
*/
{
}
42
Actividad 8 Invocar un mismo método varias veces
Modifique el ejemplo anterior para:

- Leer los datos de otros 2 rectángulos y hallar para cada uno de ellos su área.
- Obtener el área promedio de los tres Rectángulos.
Ejemplo 2 Conversión de temperatura
El Programa 2 permite convertir una temperatura dada en Fahrenheit a centígrados. El método calcularConversion
tiene como parámetro la variable fahr. Para realizar la conversión se aplica la fórmula:
Observe que la expresión escrita en el método es:
resultado= (5/9.0)* (fahr -32).
No se escribe 5/9, dado que entero dividido entre entero da entero, es decir, esta operación daría 0. En su lugar se
escribe 5/9.0, para que no se pierdan los decimales.
Programa 2 Convertir de Fahrenheit a centígrados
/**
* Clase que representa operaciones sobre una temperatura
* @author sonia
* del Quindio
*/
public class Conversion {
/**
* Metodo principal
*/
double centigrado, fahr;
String mensaje1= "Ingrese la temperatura en fahr";
fahr= leerDouble (mensaje1);
centigrado = calcularconversion(fahr);
imprimir("La temperatura en centigrados es "+centigrado);
}
/**
* Permite convertir de fahr a centigrados
* @param fahr La temperatura dad en fahrenheit
* @return la temperatura en centigrados
*/
public static double calcularconversion(double fahr)
{
double resultado=0;
resultado= (5/9.0)* (fahr -32);
return resultado;
}
/**
43
*/

{
return dato;
}
/**
*/
{
}
Ejecución
Ejemplo 3 Sumar las cifras de un número entero de 3 cifras
El Programa 3 permite obtener la sumatoria de las 3 cifras de un número entero. Esto se realiza mediante el método
calcularSumatoria, que tiene como parámetro a número y devuelve un entero con el resultado. Las expresiones
escritas dentro del método son:
centenas=numero/100;
decenas= (numero%100)/10;
unidades= numero%10;
Para explicar estas expresiones observe el siguiente cociente:
123 100
23 1
Si el número es 123, entonces centenas=numero/100, sería igual a centenas=123/100=1
Dado que decenas= (numero%100)/10, entonces decenas= (123%100)/10= (23)/10=2

Finalmente, unidades= numero%10,
123 10
3 12
por lo que unidades= 123%10= 3
44
Programa 3 sumar las cifras de un numero de tres cifras
public class Sumatoria {
/**
* Metodo principal
*/
int numero;
int sumatoria;
String mensaje1= "Ingrese el numero";
numero= leerEntero (mensaje1);
sumatoria = calcularSumatoria(numero);
imprimir("La sumatoria es "+sumatoria);
}
/**
* Permite convertir de fahr a centigrados
* @param fahr La temperatura dad en fahrenheit
* @return la temperatura en centigrados
*/
public static int calcularSumatoria(int numero)
{
int centenas, unidades, decenas, suma;
centenas=numero/100;
decenas= (numero%100)/10;
unidades= numero%10;
suma=unidades+decenas+centenas;
return suma;
}
}
1.8 Taller de métodos
a. Construir un programa que calcule el área sombreada (rayada) del rectángulo, si se ha dibujado una mascota
dentro de él 4.
4
Figura basada en http://compumch.webnode.es/a1%C2%B0-primaria-iii-b/actividad-3-19-8-15-herramienta-borrador-
dibujo-figuras-geometricas/
45
public class Mascota {
public static double calcularAreaTriangulo(double base,

double altura)
{
double area= (base*altura)/2;
return area;
}
public static double calcularAreaRectangulo(double largo,
double ancho)
{
double area= (largo*ancho);
return area;
}
public static double calcularAreaCuadrado(double lado)

{
double area= (lado*lado);
return area;
}
public double calcularAreaCabeza (double a) public double calcularAreaTotalMascota(double a)

{//aqui debe invocar los métodos para calcularAreas {
double areaCabeza=0;
}
public double calcularAreaSombreada(double a)
{
return areaCabeza;
}
public double calcularAreaCuerpo (double a) }
{//aqui debe invocar los métodos para calcularAreas public static void main(String[] args) {
double areaCuerpo=0;
}
return areaCuerpo; }
}
b. Resuelva todos los puntos de la activad 3 haciendo uso de métodos.
Nota: Para los puntos que involucren áreas de figuras geométricas retomar los métodos de áreas del ejercicio
anterior. También debe implementar un método para hallar un cateto y otro método para hallar Hipotenusa.
46
2. Estructuras de decisión
- Utilizar estructuras de decisión como parte del cuerpo de un método
- Identificar las responsabilidades de los métodos, diferenciando claramente cuales de los métodos
construidos corresponden a lectura de datos o visualización de información y cuáles a la lógica.
47
48
2. Estructuras de decisión
En Java se manejan dos estructuras de selección if y switch.
1.1 Instrucción If
La instrucción if, evalúa la condición, si el resultado es verdadero ejecuta las acciones encerradas dentro de llaves
(grupoDeAcciones1). El grupoDeAcciones1 puede ser simple o compuesto. Si la condición es falsa, no se ejecuta
ninguna acción.
if( condición )
grupoDeAcciones1
}
Por ejemplo, si se desea cambiar calcular la raíz cuadrada de un número se puede escribir:
double raiz=0;
if(numero>=0)
{
raiz=Math.sqrt(numero);
}
Una variante de esta estructura de decisión es el if-else. En ella se evalúa la condición y si es verdadera se ejecutan
las acciones encerradas dentro de llaves, en caso contrario se ejecuta grupoDeAcciones2
if ( condición )
{
grupoDeAcciones1
}
else
{
grupoDeAcciones2
}
En el siguiente ejemplo si el número es positivo o cero, se calcula la raíz cuadrada, de lo contrario la variable raíz se
inicializa con cero.
49
double raiz=0;
if(numero>=0)
{
raiz=Math.sqrt(numero);
}
else
{
raiz=0;
}
Algunas instrucciones sencillas pueden escribirse mediante un if in-line. El siguiente ejemplo ilustra su uso. Si numero
es menor que 10, entonces se le asigna el valor de 6, de lo contrario se le asigna 23.
int numero=0;
numero=((numero<10)? 6:23);
Otra variante es el if anidado, que se caracteriza porque la instrucción que sigue a un else es un if (excepto la última
que podría ser un único else). En un if anidado, las condiciones se evalúan de forma descendente, es decir, solo
pasa a la siguiente, si la anterior no es verdadera. Cuando la condición es verdadera se efectúa el bloque de
instrucciones correspondiente y se omite el resto de la estructura. Si ninguna se cumple se efectúa la acción del
último else.
Las condiciones se evalúan en orden descendente pasando de una a otra si la anterior resulta fals a. En el momento
que se encuentra una condición verdadera, se efectúa la acción correspondiente a dicha condición y se corta el resto
de la estructura. Si todas las condiciones resultan falsas se efectúa la acción correspondiente al último else.
Ejemplo 4 Determinar si es mayor de edad
Esta aplicación lee la edad y luego evalúa si es mayor o igual que 18, en tal caso se inicializa una variable con el
mensaje “es mayor de edad”, de lo contrario, se inicializa con “es menor de edad”.
50
Para ilustrar el uso la instrucción condicional en Java se presenta el método isMayor, que informa si una persona
es o no mayor de edad. Tiene como parámetro la edad.
Programa 4 Identifica si una persona es mayor de edad
/**
* Clase que representa operaciones sobre la edad de una persona
* @author sonia
* del Quindio
*/
public class EvaluacionEdad {
/**
* Metodo principal
* @param args Los argumentos de la linea de comandos
*/
int edad=0;
String resultado;
edad= leerEntero ("Ingrese la edad");
resultado=isMayor(edad);
imprimir(resultado);
}
/**
* Permite identificar si una persona es o no mayor de edad
* @param edad La edad de la persona, edad>=0
* @return Un mensaje Es mayor de edad (si es mayor de edad), Es menor
* de edad en caso contrario
*/
public static String isMayor(int edad)
{ String salida="";
if(edad>=18)
{
salida="Es mayor de edad";
}
else
{
salida="Es menor de edad";
}
return salida;
51
}
/**
*/
{
return dato;
}
/**
*/
{
}
Ejecución
Ejemplo 5 Las notas del estudiante
El Programa 5 lee tres notas parciales de un estudiante y calcula su definitiva (promedio aritmético). Además informa
si la definitiva es Deficiente, aceptable, buena o excelente e indica la cantidad de parciales que ganó.
Para calcular la nota definitiva se implementa el método calcularPromedio, que tiene 3 parámetros nota1, nota2,
nota3. La definitiva se calcula mediante la expresión: prom=(nota1+nota2+nota2)/3;
Para obtener la valoración se construye el metodo obtenerValoracion, que recibe como parámetro una nota. La
valoración se emite teniendo en cuenta los siguientes criterios:
Rango Valoración
[0,3) Deficiente
[3,4) Aceptable
[4,4.5) Bueno
[4.5, 5] Excelente
52
A continuación se presenta un paralelo comparativo entre dos implementaciones del método obtener valoración. Se
sugiere utilizar la segunda, dado que consta de un único retorno. Una buena práctica de programación es usar un
único retorno por método, que se ubica como última instrucción del método [3].
Evitar esta práctica Se sugiere realizar esto

public static String obtenerValoracion(double public static String obtenerValoracion(double nota)
nota) {
{ String valoracion;
String valoración=""; if(nota>=0&&nota<3)
if(nota>=0&&nota<3) {
{ valoracion="Deficiente";
return "Deficiente"; }
} else
else if(nota>=3&&nota<4)
if(nota>=3&&nota<4) {
{ valoracion="Aceptable";
return Aceptable"; }
} else
else if(nota>=4&&nota<4.5)
if(nota>=4&&nota<4.5) {
{ valoracion="Bueno";
return Bueno"; }
} else
else { valoracion="Excelente";}
{ return Excelente";}
return valoracion;
return valoracion; }
}
Para obtener la cantidad de parciales ganados se implementa el método contarGanados, que tiene tres parámetros.
Cada uno de ellos corresponde a una nota parcial. Para determinar la cantidad de parciales ganados se declara un
contador y se plantean tres if, los cuales NO pueden ir anidados. Si se anidan solamente contarían una de las tres
notas. Finalmente se retorna el contador. La aplicación completa se presenta en el Programa 5.
Programa 5 Valoración de una nota
/**
*
* @author sonia
* del Quindio
*/
public class Valoracion {
/**
* El metodo principal
*/
double nota1, nota2, nota3;
double notaDef;
String valoracion;
53
int resultado;
nota1 = leerDouble ("Ingrese la nota 1");
//Se valida que las tres notas sean correctas
if(isCorrecta(nota1)==true&&isCorrecta(nota2)==true&&isCorrecta(nota1)==true)
{
notaDef = calcularPromedio( nota1, nota2, nota3);
valoracion = obtenerValoracion(notaDef);
resultado=contarGanados(nota1, nota2, nota3);
imprimir("La nota definitiva es: "+notaDef+"\nLa nota es "+valoracion+"\nGano
"+resultado+ " parciales" );
}
else
{
imprimir("Ingreso valores incorrectos, Se aceptan notas de 0 a 5");
}
}
/**
* Calcula la nota promedio
* @param nota1 La nota 1, nota1>=0 &&nota1<=5
* @param nota3 La nota 3, nota>=0 &&nota<=5
* @return La nota promedio
*/
public static double calcularPromedio(double nota1, double nota2, double nota3)
{
double prom;
prom=(nota1+nota2+nota2)/3;
return prom;
}
/**
* Obtiene la cantidad de parciales ganados
* @param nota3 La nota 3, nota>=0 &&nota<=5
* @return La cantidad de parciales ganados
*/
public static int contarGanados(double nota1, double nota2, double nota3)
{
int contador=0;
//No se pueden anidar
if(nota1>=3)
{contador++;}
if(nota2>=3)
{contador++;}
if(nota3>=3)
{contador++;}
return contador;
}
/**
* Se obtiene la valoracion de una nota
* @param nota La nota del estudiante, nota>=0 &&nota<=5
* @return La valoración
*/
public static String obtenerValoracion(double nota)
{
54
String valoracion;
if(nota>=0&&nota<3)
{
valoracion="Deficiente";
}
else
if(nota>=3&&nota<4)
{
valoracion="Aceptable";
}
else
if(nota>=4&&nota<4.5)
{
valoracion="Bueno";
}
else
{ valoracion="Excelente";}
return valoracion;
}
/**
* Verifica que la nota este en el rango indicado
* @param nota La nota ingresada por el usuario
* @return Un boolean, true si la nota es correcto
*/
public static boolean isCorrecta(double nota)
{
boolean centinela=true;
if(nota<0||nota>5)
{centinela=false;}
return centinela;
}
Ejecución
Ejemplo 6 El Minimercado
La siguiente aplicación maneja la información referente a un minimercado, que ha puesto en oferta cierto producto,
para ello ofrece un descuento del 13% si compra más de 3 docenas y de 10% en caso contrario. El minimercado
para cautivar a su clientela está dando un obsequio por cada docena en exceso sobre 3. Se calcula el monto a pagar
y el número de unidades de obsequio, para ello se pide como parámetro al número de docenas y al precio por
docena.
55
El diagrama de flujo ilustra el proceso a seguir para calcular el valor a pagar. Para ello se debe tener en cuenta la
cantidad de docenas y el precio por docena. Si la cantidad de docenas es mayor que 3, el descuento es del 13%,
de lo contrario es del 10%.
calcularValorApagar tiene como parámetros a numDocena y precioDocena. En este método en primer lugar se
calcula el descuento, para ello se evalúa si la cantidad de docenas es mayor que 3, en tal caso aplica un descuento
del 13%, de lo contrario del 10%. Posteriormente, mediante la precioPagar=precioPagar – descuento, se obtiene el
precio final a pagar.
El cálculo del obsequio, se realiza mediante el método calcularObsequio. Este método tiene como parámetro a
numDocena. La variable obsequio se inicializa en cero y mediante un if, se evalúa si la cantidad de docenas es
superior a 3, en tal caso, el obsequio se modifica mediante la expresión obsequio=numDocena-3. Finalmente se
retorna la variable obsequio. La aplicación completa se muestra en el Programa 6.
Programa 6 Minimercado
/**
*
* @author sonia
* del Quindio
*/
public class Minimercado {

int numDocena, obsequio;
double precioDocena, precioPagar;
numDocena = leerEntero("Ingrese el numero de docenas");
precioDocena = leerDouble("Ingrese el precio de la docena");
precioPagar = calcularValorApagar(numDocena, precioDocena);
obsequio = calcularObsequio(numDocena);
imprimir ("El valor a pagar es "+precioPagar+"\nEl obsequio es "+obsequio+" unidades");
}
/**
56
* Calcula el valor a pagar
* @param numDocena El numero de docenas compradas, numDocenas>=0
* @param precioDocena El precio de la docena, precioDocena>0
* @return El valor a pagar
*/
public static double calcularValorApagar (double numDocena, double precioDocena)
{
double precioPagar;
double descuento = 0;
precioPagar = numDocena*precioDocena;
if(numDocena > 3)
{
descuento=precioPagar*0.13;
}
else
{descuento=precioPagar*0.10;};
precioPagar=precioPagar - descuento;
return precioPagar;
}
/**
* Calcula el obsequio que se entregara por la compra
* @param numDocena La cantidad de docenas, numDocenas>=0
* @return El obsequio
*/
public static int calcularObsequio(int numDocena)
{
int obsequio=0;
if(numDocena>3)
{obsequio=numDocena-3;}
return obsequio;
}
Ejecución
57
2.2 Instrucción switch
La instrucción switch, permite elegir entre diferentes rutas, haciendo uso de una variable denominada selector. El
selector es comparado con una serie de constantes. En caso de que el selector coincida con alguno de ell os, se
efectua el bloque de instrucciones correspondiente a dicha constante. En caso de no coincidir con ninguno se efectua
la acción por defecto (default), si es que esta existe. Esta instruccion funciona con los tipos de dato primitivos byte,
short, int y char. Tambien con Strings, y las clases Byte, Short, Integer y Character. También funciona con tipos de
datos enumerados (que se construyen mediante Enum).
El switch tiene la siguiente sintaxis:
switch ( selector )
{
case constante1 : acción A1
break;

break;

break;
.
.
.
case constanteN : acción An
break;
default : acción por defecto

}
Cada uno de estos valores dentro del case “constante” debe ser único, es decir, no se pueden definir rangos.
Observe que se hace uso de la sentencia break, para romper, es decir, para que no continue con el siguiente caso
(salta fuera del switch).
Ejemplo 7 Determinar la estación del año.
Este ejemplo primero lee un numero entre 1 y 12 y mediante el uso de la instrucción de selección múltiple determina
a que estación correponde. Obserque que si el mes es 12,1 ó 2, la estación correspondiente es Invierno. Si el mes
es 3, 4, 5 la estación es primavera, si es 6, 7, 8 la estación es verano, si es 9,10, 11 la estación es otoño.
En la implementación en Java, que se muestra en el Programa 7, esto se logra mediante el método

hallarEstacionAnio, que tiene como parámetro un numeroMes. Observe que por ejemplo para el caso 12, 1 y 2, el
58
set de instrucciones a ejecutar es el mismo, por ello es suficiente con ponerlo al final. El break hace que salga del
switch.
case 12:
case 1:
case 2: estacionAnio = "Invierno";
break;
Programa 7 Estaciones del año
/**
*
* @author sonia
* del Quindio
*/
public class Estacion {

/**
* El metodo principal
*/
int numeroMes;
String estacion;
numeroMes=leerEntero("digite un numero entre 1 y 12");
if(verificarNumero(numeroMes)==true)
{
estacion=hallarEstacionAnio(numeroMes);
imprimir ("La estacion correspondiente es "+estacion);
}
else
{imprimir("Ingrese un numero en el rango valido 1 y 12");}
}
/**
* Permite validar el numero ingresado
* @param numero Un numero entero
* @return Un boolean, true si esta entre 1 y 12
*/
public static boolean verificarNumero(int numero)
{ boolean centinela=true;
if(numero<1|| numero>12)
{centinela =false;}
return centinela;
}
/**
* Dado el mes, obtiene la estacion del anio
* @param numeroMes El numero de mes, numero>0&&numero<13
* @return La estacion
*/
public static String hallarEstacionAnio(int numeroMes)

{
59
String estacionAnio="";
switch( numeroMes )
{
case 12:
case 1:
case 2: estacionAnio = "Invierno";
break;
case 3:
case 4:
case 5: estacionAnio = "Primavera";
break;
case 6:
case 7:
case 8: estacionAnio = "Verano";
break;
case 9:
case 10:
case 11: estacionAnio = "Otoño";
break;
}
return estacionAnio;
}
Ejemplo 8 La calculadora
Esta calculadora realiza las cuatro operaciones básicas (suma, resta, multiplicación y división). El método
realizarCalculo se encarga de realizar la operación solicitada, haciendo uso de la instrucción switch. Este método
tiene 3 parametros, los dos primeros corresponden a los números con los que se desea realizar la operación (double
a y double b) y el último al operador. El operador (variable selector) puede tomar los valores de +, -, *, /. El retorno
es de tipo String dado que debe considerarse la división por cero. Si el divisor es cero (y por ende, centinela es
false), entonces la variable resultado se inicializa con el texto "DivByZero", de lo contrario, se inicializa con el
resultado de la operación realizada.
Programa 8 Calculadora
/**
*
* @author sonia
* del Quindio
*/
public class Calculadora {

/**
* Metodo principal
* @param args Los argumentos de la linea de comand
*/

double a, b;
60
char operador;
String resultado="";
a=leerDouble("Ingrese a ");
b=leerDouble("Ingrese b ");
operador=leerChar("Ingrese el operador ");
resultado=realizarCalculo(a,b, operador);
imprimir ("El resultado es "+resultado);
}
/**
* Permite realizar la operacion
* @param a el operando 1
* @param b el operando 1
* @param operador El operador +, -, *, /
* @return
*/
public static String realizarCalculo(double a, double b, char operador)
{
String resultado="";
boolean centinela=true;
double res=0;
switch ( operador )
{
case '+':
res=a+b;
break;
case '-':
res=a-b;
break;
case '*':
res=a*b;
break;
case '/':
if (b==0)
{centinela=false;}
else
{res=( a / b );}
break;
}
if(centinela==false)
{resultado="DivByZero";}
else
{resultado=""+res;}
return resultado;
}
}
61
Ejecucion
2.3 Taller estructuras de decisión
1. Calcular el número de pulsaciones máximas que puede tener una persona luego de realizar ejercicio aeróbico;
la fórmula que se aplica cuando el sexo es femenino es:
cantPulsaciones = (225-edad)*0.85
Y si es masculino
cantPulsaciones = (210-edad) *0.85
2. Maluma cobra 2.000.000 por cada canción que interprete, pero ofrece un descuento de acuerdo al número de
canciones que interprete, el cual está dado por la siguiente tabla:
No. De canciones % de canciones
1-3 5%
4-10 10%
11-15 13%
16-en adelante 20%
3. Construya un programa que permita calcular el nuevo sueldo de un trabajador, teniendo en cuenta que si el sueldo
es inferior o igual a $760.000 tendrá un aumento de $50.000, si es mayor de esto pero inferior a 2.200.000 el
incremento será del 10% de lo que gana actualmente, de lo contario será del 8%.
4. Calcular el descuento pagado total por dos artículos. El descuento por artículo se obtiene de acuerdo a la siguiente
tabla.
Precio en miles Descuento
0-15 0%
Mas de 15 hasta 20 7%
Mas de 20 hasta 60 20%
Mas de 60 35%
5. Construir un problema que calcule las raíces de una ecuación cuadrática
6. Informa el lugar que visitará un turista, si se sabe el mes en el que desea viajar, la edad del turista, la cantidad de
días a permanecer en el territorio, y su presupuesto. El sitio asignado para el viaje depende de las estaciones, de la
disponibilidad para trabajar y de otras condiciones que se presentan a continuación:
-Si el mes en el que el turista desea viajar corresponde a Invierno, hay dos opciones de viaje: Turkia o Gran Bretaña
. Si su presupuesto es superior a 20 millones, el turista viajará a Gran Bretaña. Cuando el turista sea menor de
edad, sin importar su presupuesto, viajará a Turkia.
- Cuando el mes corresponda a Verano, el turista, que debe ser mayor de edad, viajará a Dubai, siempre y cuando
permanezca más de 10 días en el territorio y pueda trabajar como mínimo 5 días en Uber. De lo contrario irá a
Cancún.
62
- Si el mes de viaje corresponde a Otoño, el turista deberá tener edad entre 40 y 65 años, y un presu puesto de 10
millones.
- Si el mes es Primavera, y el turista no puede trabajar, pero su presupuesto es superior a 22 millones, irá a Japón.
- Si el turista no cumple con ninguna condición previa, deberá viajar a Perú.
Informar el sitio que debe visitar el turista.

Tabla de equivalencia Mes - estación.
12, 1, 2 Invierno 3, 4, 5 Primavera 6, 7, 8 Verano 9, 10, 11 Otoño
7. Se desea crear una aplicación para informar el obsequio que recibirá una mujer en una tienda de ropa. Las
condiciones para la entrega del obsequio son las siguientes:
- Si tiene tarjeta Platinum, un acumulado de puntos superior a 20000, sus compras anuales son inferiores a
4.5 millones y tiene la tarjeta desde hace 2 o más años, se entregará un bolso.
- Si su tarjeta es platinum, el acumulado de puntos es inferior o igual a 20000 recibirá una cosmetiquera.
- Si su tarjeta de puntos es Gold, posee la tarjeta desde hace 2 o más años, tiene edad superior a 45 años y
acumulado de compras anuales superior a 10 millones, se le dará una pulsera.
- Si su tarjeta es Gold, su edad está entre 18 y 45 años y cumple años en el mes actual, se le regalará un
Brazalete.
- Si tiene alguna de las tarjetas, y no cumplió ninguna de las condiciones anteriores, y su promedio de compras
anuales es de 6 millones de pesos se le regalará una cosmetiquera.
- Si no tiene tarjeta pero su promedio de compras excede los 15 millones, se le regalará iphone 6s.
- Si no cumple ninguna de las condiciones anteriores no recibirá obsequio.
63
64
3. Estructuras repetitivas
- Utilizar estructuras repetitivas como parte del cuerpo de un método.
- Identificar las responsabilidades de los métodos, diferenciando claramente cuales de los

métodos construídos corresponden a lectura de datos o visualización de información y cuáles a la
lógica.
65
66
3. Estructuras repetitivas
Java maneja tres tipos de estructuras repetitivas: for, while y do-while. Cada una de estas estructuras consta de 3
elementos: inicialización, decision (condición a evaluar) y cuerpo del bucle (si la evaluación de la condición da como
resultado verdadero, se repite el listado de instrucciones un cierto número de veces). Si luego de evaluar la condición
da como resultado false, el ciclo finaliza.
Una forma de controlar la ejecución del ciclo es haciendo uso contadores y acumuladores. Un contador, se
caracteriza por tener un incremento o decremento constante. La segunda, almacena valores variables, que son el
resultado de operaciones continuas.
3.1 Instrucción for
La expresión de inicialización, se efectúa solamente una vez. Luego se examina la condición, y si es verdadera, se
efectúa el cuerpo del ciclo. En cada iteración, se evalúa de nuevo la condición y si es verdadera, se vuelve a repetir
el cuerpo del método. Si la expresión de control es falsa, finaliza el ciclo.
for ( inicialización; condicion; iteración )

{
grupoDeAcciones
}
3.2 Instrucción while
El ciclo while, el grupo de acciones se repite siempre y cuando se cumpla la condición indicada dentro de paréntesis
es decir, sea verdadera). Cuando se terminan de ejecutar las instrucciones dentro del while, se vuelve a evaluar la
condición, si da falso se finaliza la ejecución del ciclo.
//inicialización
while( condición )
{ //grupoDeAcciones
//modificacion de la variable de control
}
3.3 Instrucción do while
Esta estructura repetitiva permite que el cuerpo del ciclo se efectue como mínimo una vez, antes de evaluar la
condición de repetición.
Su sintaxis se presenta a continuación,
do
{
//grupoDeAcciones
} while( condición );
67
3.4 El depurador de Eclipse
El depurador de Eclipse permite ejecutar el código línea a línea, para verificar la aplicación en tiempo de ejecución.
Para ilustrar su uso se trabaja sobre el proyecto Sumatoria. Para ejecutar hacer uso del depurador es necesario abrir
las vistas BreakPoints, Debug, Expresion y Variables. Esto se logra dando clic en window>show view> other, tal
como se muestra a continuación:
68
Por cada línea que se desee verificar se agrega un BreakPoint, esto se hace dando doble clic a la izquierda de dicha
instrucción.
A continuación se procede a ejecutar el programa con el Debug, para ello de clic en la barra de menú principal y
seleccione Run – Debug.
69
La primera pantalla que aparece es:
Observe que en la pestaña variable aparecen las variables de interés.
70
Para continuar con la ejecución se puede elegir entre las siguientes opciones: línea por línea (tecla F5) o correr el
método completo (tecla F6). Para este ejemplo ser presiona sucesivamente F5. Observe que el método
calcularSumatoria empieza a ejecutarse y la variable sumatoria se inicializa en 0.
A continuación se inicia la ejecución del for, que va desde1 hasta finaliza.
71
El valor de la sumatoria se inicia en 1.
Cuando la i vale 2, el valor de la sumatoria pasa a ser 3.0.
El valor de la i se incrementa, y queda valiendo 3.
72
Ahora el valor de la sumatoria es 6 y se va a dar un nuevo incremento de la i.
El valor de la i queda en 4.
La variable sumatoria queda con el valor de 10.
La i incrementa y queda valiendo 5, como 5 no es menor que finaliza se termina la ejecución del for.
73
Observe que si se activa la pestaña expressions, podrá agregar variables o expresiones. Por ejemplo podría estar
interesado en comparar el valor de la sumatoria con otra variable o un valor.
Observa que cuando una variable cambia su valor, en la ventana de variables se verá de color amarillo (siempre y
cuando se haya presionado la tecla F7).
Ejemplo 9 Sumatoria de los números de 1 a n.
Esta aplicación se encarga de calcular la sumatoria de los números entre 1 y n. La sumatoria se implementa haciendo
uso de diferentes tipos de estructuras repetitivas. Los diagramas de flujo que se presentan a continuación ilustran el
uso de la estructura for , while y do-while, respectivamente.
74
En lo que respecta a la implementación en Java, mostrada en el Programa 9 , se contruye el método
calcularSumatoria. Este tiene un parámetro de tipo entero llamado finaliza, que indica hasta donde debe llegar la
sumatoria. El for se trabaja con la variable i, que toma valores entre 1 y finaliza. Si al evaluar la condición i<=finaliza,
da como resultado true, entonces, se acumula el valor de i, ello se logra mediante la instrucción
sumatoria=sumatoria+i;
Programa 9 Sumatoria
/**
*
* @author sonia
* del Quindio
*/
/**
* Programa para calcular la sumatoria desde 1 hasta n
*
* @author Sonia
*/
public class Sumatoria{
/**
*/
public static void main( String[] args ) {
int finaliza;
double sumatoria;
sumatoria=0;
finaliza = leerEntero( "Ingrese un entero positivo: " );
if(finaliza>=1)
{
sumatoria=calcularSumatoria(finaliza);
imprimir( "La sumatoria es:\n" +sumatoria );
}
else
75
{
imprimir("El numero ingresado debe ser positivo");
}
/**
* Método para calcular la sumatoria desde 1 hasta n
* @param finaliza Final del intervalo, finaliza>0
* @return La sumatoria
*/
public static double calcularSumatoria( int finaliza )
{
double sumatoria;
sumatoria=0;
for(int i=1; i<=finaliza; i++)

{ //Esto es equivalente a sumatoria+=i;
}
return sumatoria;
}
/**
* Método para leer un número entero
*
* @param pregunta Texto con un pregunta para el usuario
* @return Número entero como respuesta a la pregunta
*/
public static int leerEntero ( String pregunta )
{
return Integer.parseInt( JOptionPane.showInputDialog( pregunta ) );
}
/**
* Método para imprimir un texto en una ventana.
*
* @param texto Texto que se desea imprimir
*/
public static void imprimir( String texto )
{
JOptionPane.showMessageDialog( null, texto );
}
76
Ejemplo 10 Calcular una sumatoria.
Esta aplicación permite calcular una sumatoria de los primeros números enteros. Para poder cumplir con el requisito
funcional solicitado se implementa el método calcularSumatoria, que tiene el parámetro topeAcumulador. El ciclo se
efectúa mientras que la variable sumatoria es menor que topeAcumulador. Cuando el ciclo finaliza se devuelve el
valor de la sumatoria. El proceso efectuado se presenta en la prueba de escritorio siguiente:
i sumatoria topeAcumulador sumatoria<topeAcumulador

- 0 7
1 0+1=1 1<7 (T)
2 1+2=3 3<7 (T)
3 3+3=6 6<7 (T)
4 6+4=10 10<7 (F)
La aplicación se presenta en el Programa 10.
Programa 10 Sumatoria Condición salida
package uniquindio.paradigma.serie.mundo;
/**
* Programa que devuelve la Sumatoria de los primeros n numeros positivos, la
* sumatoria finaliza cuando la misma excede un valor ingresado por el usuario,
* Ejemplo: si el usuario ingresa 25, entoces sumará:
* 1+2=3
* 3+3=6
* 6+4=10
* 10+5=15
* 15+6=21
* 21+7=28. El valor de 28 excede 25 por lo tanto devuelve 28
*
*
* @author sonia
* del Quindio
*/
*/
public class Sumatoria{
/**
*/
int topeSumatoria;
double sumatoria;
sumatoria=0;
topeSumatoria = leerEntero( "Ingrese el tope de la sumatoria: " );
if(topeSumatoria>=1)
77
{
sumatoria=calcularSumatoria(topeSumatoria);
imprimir( "La sumatoria es:\n" +sumatoria );
}
else
{
imprimir("El numero ingresado debe ser positivo");
}
/**
* Método para calcular la sumatoria desde 1 hasta n
* @param topeAcumulador El tope del acumulador, topeAcumulador>0
* @return La sumatoria
*/
public static double calcularSumatoria( int topeAcumulador )
{
double sumatoria;
sumatoria=0;
for(int i=1; sumatoria<topeAcumulador; i++)

{ //Esto es equivalente a sumatoria+=i;
}
return sumatoria;
}
/**
*
*/
{
}
/**
*
*/
{
}
}
78
Ejemplo 11 Mostrar los números enteros en el intervalo cerrado [inicio, finaliza]
Esta aplicación permite calcula la sumatoria de los números enteros del intevalo [inicio, finaliza]. La sumatoria se
calcula de tres formas diferentes: haciendo uso de while, for y do-while.
El primer método, generarSerieEnterosWhile, tiene dos parámetros inicio y finaliza. El ciclo se controla mediante la
variable i que toma el valor de inicio y deja de ejecutarse cuando la i excede el valor de la variable finaliza.
El método generarSerieEnterosFor, funciona de forma similar al método anterior, se declara la variable i, que toma
el valor de inicio y tiene como condición de salida i<=finaliza.
Finalmente, generarSerieEnterosDoWhile, evalua primero que inicio sea menor o igual que finaliza, esto evita que
se de un ciclo infinito (en caso de que los valores estén trocados). Si ambos valores llegan correctos, se ejecuta el
do-while. El cuerpo del ciclo se ejecuta almenos una vez.
Programa 11 Intervalo
/**
* Programa que devuelve la representación en String de los los números enteros que se encuentran en un
intervalo cerrado [inicio, finaliza]
*
*
*
* @author sonia
* del Quindio
*/
public class Serie {
/**
*/
int inicio, finaliza;
String serie;
serie="";
inicio = leerEntero( "Ingrese el inicio del intervalo: " );
finaliza = leerEntero( "Ingrese el final del intervalo: " );
serie += generarSerieEnterosWhile ( inicio , finaliza );

serie +="Resultado con while \n";
serie += generarSerieEnterosFor ( inicio , finaliza );

serie += "Resultado con for \n";
serie += generarSerieEnterosDoWhile ( inicio , finaliza );
79
serie += "Resultado con do while \n";
imprimir( "La serie es:\n" + serie );
}
/**
* Método para generar la serie de números enteros en el intervalo cerrado[ inicio, final ]
* @param inicio Inicio del intervalo
* @param finaliza Final del intervalo
* @return La serie de números enteros
*/
public static String generarSerieEnterosWhile( int inicio, int finaliza )
{
String salida;
int i;
salida = "";
i = inicio;
while ( i <= finaliza )

{
salida += i + " ";
i++;
}
return salida;
}
/**
*/
public static String generarSerieEnterosFor( int inicio, int finaliza )
{
String salida;
salida = "";
for(int i= inicio; i<=finaliza; i++)

{
salida += i + " ";
}
return salida;
}
/**
*/
public static String generarSerieEnterosDoWhile( int inicio, int finaliza )
{ int i;
String salida;
salida = "";
i= inicio;
80
//se verifica que inicio sea menor o igual que final, si da false, el ciclo no deberia efectuarse
if(inicio<=finaliza)
{
do{
salida += i + " ";
i++;
}while(i<=finaliza);
}//cierra if
return salida;
}
/**
*
*/
{
}
/**
*
*/
{
}
Ejemplo 12 Serie Fibonacci
81
Esta aplicación permite mostrar los primeros n términos de la serie Fibonacci. En esta serie el siguiente término
corresponde a la suma de los dos anteriores. Por ejemplo, si el usuario ingresa 5 términos imprime 0 1 1 2 3.
El método implementado para resolver este requisito funcional se denomina calcularFibonacci y recibe como
parámetro n. Para generar la serie se hace uso de tres variables: anterior, siguiente y auxiliarSumaIntermedia. El
ciclo se ejecuta mientras que el contador de términos es menor que n. En tal caso, se almacena en suma intermedia
el valor de anterior+siguiente. Este auxiliar es importante, dado que la asignación es una operación destructiva, es
decir, luego de asignar un valor, el que tenía previamente desaparece. Para comprender este concepto observe la
siguiente tabla.
Tabla 15 Comparativo asignación de variables
Incorrecto Correcto
while(contador<n) while(contador<n)
{ {
serie+= anterior+" "; serie+= anterior+" ";
anterior=siguiente; auxiliarSumaIntermedia=anterior+siguiente;
//la asignacion es destructiva anterior=siguiente;
siguiente=siguiente+anterior; siguiente=auxiliarSumaIntermedia;
contador++; contador++;
} }
Prueba de escritorio Prueba de escritorio
contador anterior siguiente contador<n serie

contador anterior siguiente auxiliarSuma contador<n serie
Intermedia
0 0 1 0<5 (T) 0
0 0 1 1 0<5 (T) 0
1 1 1+1=2 1<5 (T) 01
1 1 1 2 1<5 (T) 01
2 2 4 2<5 (T) 012
2 1 2 3 2<5 (T) 011
3 4 8 3<5 (T) 0124
3 2 3 5 3<5 (T) 0112
4 8 16 4<5 (T) 0124 8
5 5<5 (F)
4 3 5 8 4<5 (T) 0112
3
5 5<5 (F)
La aplicación se muestra en el Programa 12:
Programa 12 Fibonacci
/**
*
* @author sonia
* del Quindio
*/
public class Fibonacci {
/**
* El método principal
* @param args Los argumentos de la línea de comandos
*/
82
int n;
String serie;
n=leerEntero("Ingrese la cantidad de términos que desea visualizar de la serie");
if(n>0)
{
serie=calcularFibonacci(n);
imprimir("La serie Fibonacci es \n "+serie);
}
else
{
imprimir("Debe ingresar un valor mayor a 0");
}
/**
* Devuelve la representacion en String de la serie Fibonacci
* @param n La cantidad de terminos a visualizar, n>0
* @return La serie Fibonacci
*/
public static String calcularFibonacci(int n)

{
String serie;
int contador;
int anterior;
int siguiente;
int auxiliarSumaIntermedia;
contador=0;
anterior=0;
siguiente=1;
auxiliarSumaIntermedia=0;
serie="";
while(contador<n)
{
serie+= anterior+" ";
auxiliarSumaIntermedia=anterior+siguiente;
anterior=siguiente;
siguiente=auxiliarSumaIntermedia;
contador++;
}
return serie;
/**
*
*/
{
83
}
/**
*
*/
{
}
Ejecución
Ejemplo 13 Factorial
Esta aplicación permite calcular el Factorial de un número. El factorial de un número se define como:
Esto también puede ser expresado como

n
n! = ∏ i
i=1
Para resolver este requisito se implementa el calcularFactorial,que tiene como parámetro a n.
La variable i se inicializa en n y va decrementado hasta llegar a 1. El cuerpo del ciclo se encarga de modificar el valor
del acumulador llamado factorial. Observe la similitud con ∏ni=1 i. El símbolo de productoria corresponde al for, que
va desde 1 a n (para ilustrar que el contador puede decrementar el for se hizo al contrario, es decir, desde n hasta
1). La expresión dentro de la productoria equivale a la instrucción factorial=factorial*i
84
Programa 13 Factorial
/**
*
* @author sonia
* del Quindio
*/
public class Factorial {
/**
*/
double factorial;
int n;
n = leerEntero( "Ingrese n: " );
if(n>=0)
{
factorial=calcularFactorial(n);
imprimir( "El factorial es:\n" +factorial );
}
else
{
imprimir("El numero ingresado debe ser positivo o cero");
}
/**
* Permite calcular el factorial de un numero
* @param n El numero al que se le calcula factorial, n>=0
* @return El factorial del número
*/
public static double calcularFactorial(int n)
{
double factorial=1;
for(int i=n; i>=1; i--)

{
factorial=factorial*i;
}
return factorial;
/**
*
*/
85
{
}
/**
*
*/
{
}
Ejemplo 14 Obtener la representación en String de un número en base 10.
Para obtener los dígitos de un número en base diez, es necesario dividir sucesivamente por 10. Observe el siguiente
ejemplo, en este caso n=1234. La primera vez n=1234, luego se divide por 10, observe que el residuo es 4. A
continuación n se convierte en 123 (es decir en el cociente de la operación anterior) y se vuelve a dividir por 10, esto
de como residuo 3. Nuevamente n cambia su valor y se convierte en 12. Luego de dividir 12 por 10 se obtiene un
residuo de 2 y un cociente de 1. Para obtener cada uno de los dígitos se toman los residuos de abajo hacia arriba,
tal como lo muestra la flecha.
1234 10
4 123 10
3 12 10
2 1
El método devolverDigitos tiene como párametro un número entero. El ciclo while se efectúa mientras que el número
se puede dividir por 10, es decir, es mayor o igual a 10. El cuerpo del ciclo contempla concatenar el módulo de la
división (digito=numAuxiliar%10) y modificar el valor del número (numAuxiliar=numAuxiliar/10).
Programa 14 Base 10
/**
* Programa para mostrar todos los digitos de un numero en base 10
*
* @author sonia
* del Quindio
*/
public class Base10 {
/**
* El método principal
86
*/
int numero;
String resultado;
numero=leerEntero("Ingrese un numero entero positivo");

if(numero>0)
{
resultado=devolverDigitos(numero);
imprimir("El numero digito por digito es: "+resultado);
}
else
{
imprimir("Solo se aceptan valores positivos");
}
/**
* Devuelve la representacion en String de un numero
* @param num El numero, num>0
* @return La representacion en String con los digitos del numero
*/
public static String devolverDigitos(int num)
{ int numAuxiliar=num;
String resultado;
int digito=0;
resultado="";
while(numAuxiliar>=10)
{
digito=numAuxiliar%10;
numAuxiliar=numAuxiliar/10;
resultado=digito+" "+resultado;
}
resultado=numAuxiliar+" "+resultado;
return resultado;
}
/**
*
*/
{
}
/**
*
*/
87
{
}
Ejemplo 15 Crear un triángulo rectángulo con asteriscos
Esta aplicación permite crear un triángulo rectángulo, tal como se muestra a continuación:
Para ello el método generarTriangulo recibe como parámetro la cantidad de filas. El triángulo se construye fila por
fila. Se tiene entonces un for anidado, en donde el for externo se encarga de manejar la cantidad de filas y el interno,
la cantidad de asteriscos por fila. Observe que el for se efectúa mientras que j <= i,es decir, si la i vale 0 entonces el
for de la j va hasta 0 (se efectúa una vez, pone un solo asterisco). Si la i vale 1, el for de la j se efectúa para 0 y 1
(se efectúa dos veces, pone 2 asteriscos). Si la i vale 2, el for de la j se efectúa para 0, 1 y 2 (se efectúa tres veces,
pone 3 asteriscos).
public static String generarTriangulo( int filas )

{
String miTriangulo;
miTriangulo = "";
for ( int i = 0; i < filas ; i++ )

{
for (int j = 0 ; j <= i ; j++ )
{
miTriangulo += "*";
}
miTriangulo =miTriangulo+ "\n";

88
}
return miTriangulo;
}
Cada vez que el valor de la i se incrementa y se cumpla la condición i < filas, se efectuará el for de la j (en este caso
particular siempre iniciará en j=0). Sólo hasta cuando se termina el for de la j se vuelve a incrementar i.
La aplicación completa se presenta en el Programa 15.
Programa 15 Triángulo
/**
* Programa para generar un triángulo con asteriscos (*)
*
*
* @author Sonia, basado en código de Julián Esteban Gutiérrez
*/
public class Triangulo {
/**
* @param args the command line arguments
*/
int filasTriangulo;
String miTriangulo;
filasTriangulo = leerEntero( "Ingrese la altura del triángulo: " );

if(filasTriangulo>0)
{
miTriangulo = generarTriangulo( filasTriangulo );
imprimir( miTriangulo );
}
else
{
imprimir("Ingrese un valor mayor que cero");
}
/**
* Método obtiene la representacion en String de un triangulo
*
* @param filas altura del triangulo.
* @return La representacion en String de un triangulo.
*/
{
String miTriangulo;
miTriangulo = "";

{
for (int j = 0 ; j <= i ; j++ )
89
{
miTriangulo += "*";
}
miTriangulo =miTriangulo+ "\n";

}
return miTriangulo;
}
/**
*
*/
{
}
/**
*
*/
{
}
}
Ejemplo 16 Programa para mostrar un triángulo isósceles.
A diferencia del ejemplo anterior, esta aplicación debe trabajar los espacios antes de empezar a concatenar
asteriscos.
90
El método generarTriangulo recibe como parámetro la cantidad de filas. El triángulo se construye fila por fila. Se
crea un for anidado, en donde el for externo se encarga de manejar la cantidad de filas. Internamente se cuenta con
dos for. El primero maneja los espacios y el segundo, la cantidad de asteriscos por fila. Para manejar la cantidad
de espacios previamente se definen las siguientes variables:
int cantidadMaxima=filas*2-1;
int mitad=cantidadMaxima/2;
El for que maneja los espacios se efectúa mientras la condición j<mitad-i sea verdadera. En tal caso concatena
espacio (fila+=" "). Cuando la condición da falso, se efectúa el siguiente for (el que controla los asteriscos). Este
último se ejecuta mientras que j <= i,es decir, si la i vale 0 entonces el for de la j va hasta 0 (se efectúa una vez, pone
un solo asterisco). Si la i vale 1, el for de la j se efectúa para 0 y 1 (se efectúa dos veces, pone 2 asteriscos). Si la i
vale 2, el for de la j se efectúa para 0, 1 y 2 (se efectúa tres veces, pone 3 asteriscos).
Programa 16 Triángulo 2
/**
* Programa para generar un triángulo rectángulo por medio de del símbolo (*)
* de una altura especificada.
*
*
*
* @author sonia
* del Quindio
*/
public class Triangulo {
/**
*/
int filasTriangulo;
String miTriangulo;
filasTriangulo = leerEntero( "Ingrese la altura del triángulo: " );

if(filasTriangulo>0)
{
miTriangulo = generarTriangulo( filasTriangulo );
91
imprimir( miTriangulo );
}
else
{
imprimir("Ingrese un valor mayor que cero");
}
/**
* Método obtiene la representacion en String de un triangulo
*
* @param filas altura del triangulo.
* @return La representacion en String de un triangulo.
*/
{
String miTriangulo;
miTriangulo ="";
int cantidadMaxima=filas*2-1;
int mitad=cantidadMaxima/2;
int totalAsteriscos=1;
String fila="";

{
fila="";
/**se agregan la cantidad de espacios necesarios para que la fila inicie corrida,
* luego se agregan los asteriscos
* por ejemplo para la fila 0 se necesitan 6 espacios y 1 asterisco
* para la fila 2 se necesitan 5 espacios y 2 asterisco2
* para la fila 3 se necesitan 4 espacios y 3 asterisco2
*/
for(int j=0; j<mitad-i; j++ )

{
fila+=" ";
}
for (int j = 0 ; j <totalAsteriscos ; j++ )

{
fila += "X";
}
totalAsteriscos+=2;
miTriangulo += fila+ "\n";

}
return miTriangulo;
}
92
3.4 Taller estructuras repetitivas
1. Construya un algoritmo que genere la tabla de multiplicar de un número n.
2. Dado un ángulo en grados convertirlo a un ángulo menor de una vuelta
3. Construya un algoritmo que dado un número n, calcule el resultado de la serie:

1- ½+ 1/3 – 1/4+ 1/5 +….+1/n
4. Construya un algoritmo que dados dos números enteros, encuentre su cociente mediante restas sucesivas
5. Escriba un algoritmo calcule la potencia de ab.
potencial = a a a ... a b veces
6. Escriba un método que imprima el término n de la siguiente serie:

1, 8, 27, 64…
7. Escriba un algoritmo que imprima el término n de la siguiente serie:

2 , 6, 8, 12, 14, 18…
8. Escriba un algoritmo que imprima el término n de la siguiente serie:

-2 , 6, -8, 12, -14, 18…
9. Escriba un algoritmo que sume todos los n términos de la serie:
1, 1/2!, 1/3!, 1/4!...
10. Dado un número informar si es primo
11. Calcular el factorial de un número usando sumas sucesivas.
12. Haga un método para descomponer un número en sus factores primos.
13. Sumar los primeros n números primos. Hacer dos métodos (uno llamado isPrimo y otro llamado sumar)
14. Haga un programa que calcule la sumatoria los pares hasta n .
15. Haga un programa que diga si un número es o no perfecto. Un número N es perfecto si la suma de sus divisores
(excluido el propio N) es N. por ejemplo 28 es perfecto, pues sus divisores (excluido el 28) son 1,2,4,7 y 14 su
suma da 28.
16. Calcular el MCD de dos números

93
17. Hallar el mcm de dos números
18. Dado un programa que dado el precio del artículo y la cantidad de dinero entregado, indique las vueltas que
deben darse, indicando el menor número de monedas. Usar restas sucesivas para el cálculo. Se sabe que se
dispone de monedas de 100, 50, 20, 5 y 1.
19. Calcular la suma de 1 + 4 + 9 + 16 + 25 + ··· + n 2
20. Imprimir el triángulo siguiente, pedir el n
n=4
*
**
***
****
***
**
*
21. Construir un programa que visualice por pantalla todos los caracteres correspondientes a letras minúsculas.
94
95
4. Estructuras contenedoras
unidimensionales de tamaño
fijo
- Utilizar estructuras contenedoras unidimensionales de tamaño fijo, para almacenar tipos de

datos primitivos o Strings.
- Hacer uso de estructuras repetitivas para recorrer este tipo de estructuras.
- Documentar programas y comprender la documentación hecha por otros para poder agregar
funcionalidades a una aplicación.
96
4. Estructuras contenedoras unidimensionales de tamaño fijo
Los arreglos son un tipo de estructura contenedora que permite almacenar elementos del mismo tipo. Para poder
hacer uso de este tipo de estructura, el arreglo primero debe declararse y luego se le debe reservar memoria
(haciendo uso del operador new). Esto se hace indicando el tipo de dato y el nombre.
int [] misEdades;
nombre
Tipo de
dato
para reservar memoria se debe utilizar el operador new tal como se muestra a continuación:
misEdades = new int[10];
Es posible efectuar a declaración y creación en una sola línea:
int misEdades [] = new int [10];
int[]misEdades = new int [10];
Los arreglos pueden tener más de una dimensión, cuando su dimensión es 2 se les conoce como matrices. Este
libro solo se enfoca en los arreglos unidimensionales.
Para poder desplazarse y obtener los elementos almacenados en dicha estructura, se requiere hacer uso de ciclos.
Cada uno de los elementos contenidos en la estructura se designan haciendo uso de un subíndice, que inicia en
cero. Por ejemplo si se tiene el arreglo misEdades el cual contiene 4 elementos, el primer elemento corresponderá
a misEdades [0], el segundo a misEdades [1], el tercero a misEdades [2] y finalmente el cuarto será misEdades
[3]. Esto permite concluir que para poder tener acceso a un elemento, se debe especificar el nombre e índice
respectivo.
En Java, cuando se declara un arreglo de un tipo de dato primitivo numérico, este automáticamente se inicializa con
ceros. Si es boolean, se inicializa con false. Debe tener precaución porque esto no ocurre en lenguajes como C++.
En tal caso será necesario hacer uso de una estructura repetitiva para fijar un valor por defecto, como se muestra a
continuación:
int misEdades [] = new int [10];

for(int i=0; i<misEdades.length; i++)
{
misEdades[i]=0
}
97
Si el arreglo es de Strings automáticamente se inicializa con null.
4.1 Pila y Stack
En Java se diferenciar dos áreas, Heap (Montículo) y Stack (Pila). La primera de ellas almacena información global
(instancias de las variables) y la segunda, almacena información de variables locales y retornos. La Figura 3 ilustra
el comportamiento de las estructuras contenedoras en las diferentes áreas de memoria 5.
Figura 3 Stack y heap
4.2 Patrones para instrucciones repetitivas
Un patrón puede verse como una solución genérica para un problema. Para trabajar con estructuras contenedoras
se se plantean 3 diferentes patrones 6:
a) Patrón de recorrido Total
Un ejemplo de este tipo de patrón es el siguiente:
public double calcularSalarioPromedio ()

{
double promedioSueldo = 0.0;
for( int i = 0; i < misSalarios.length ; i++)

{
promedioSueldo += misSalarios[ i ]ñ
}
}
5
Basado en los ejemplos creados por el Julián Esteban Gutierrez, también docente de la Universidad del Quindío, presentes en su material de clase Introducción
a la Programación en Java2.
6
Estos patrones están descritos en el libro Fundamentos de Programación. Aprendizaje activo Basado en Casos de Jorge Villalobos y Rubby Casallas
98
La variable length, devuelve la longitud del vector. Observe que el índice va desde 0 hasta misSalarios.length-1.
Si el índice se encuentra por fuera de este rango se genera una excepción.
b) Patrón de Recorrido Parcial
El recorrido se interrumpe cuando se cumple una condición. Un ejemplo de este tipo de patron se presenta a
continuación, en el que el ciclo deja de ejecutarse cuando se encuentra un salario superior a 5000000.
public int encontrarSalario()

{
boolean centinela = false;
int pos;
//Se devuelve la posición en donde se encuentra a la primera persona con salario> 5000000
for( int i = 0; i < misSalarios.length && centinela != true ; i++)
{
if(misSalarios [ i ] > 5000000)
{
centinela = true;
pos=i;
}
}
return pos;
}
Se sugiere al lector evitar el uso de sentencias tales como break y continue para construir un recorrido parcial. Es
decir, sentencias que rompan el flujo secuencial de ejecución de la aplicación. La sentencia break, finaliza la
ejecución del ciclo y salta a la primera línea del programa que se debe ejecutar tras el ciclo. Por su parte, continue
finaliza la iteración actual y salta a la siguiente iteración de la estructura repetiva sin salir de ella [7]. En [3] se
desaconseja el uso de ambas, dado que existe la posibilidad de que el programador primero plantee el ciclo y luego
verifique rústicamente su funcionamiento mediante ensayo y error. La invitación a no usar estas instrucciones sugiere
entonces que es mejor pensar la condición o invariante para que el ciclo se ejecute (y no al contrario), y a
continuación crear el cuerpo del ciclo. Esta técnica hace mucho más legible el programa y facilita su posterior
verificación.
c) Patrón de doble recorrido
Con este patrón por cada uno de los elementos del arreglo se debe realizar un recorrido completo.
99
public int determinarMayorFrecuencia()
{
int edad, contador = 0, mayorFrecuencia = 0, guardaContador = 0;
for( int i = 0 ; i < misEdades.length ; i++ )

{
edad = misEdades[ i ];
contador = 0;
for( int j = 0 ; j < misEdades.length; j++ )

{
if( i != j )
{
if( edad == misEdades [j])
{
contador++;
}
}
}
if( contador > guardaContador )

{
guardaContador = contador;
mayorFrecuencia = i;
}
}
return misEdades [ mayorFrecuencia ];

}
4.3 Clase Arrays
Esta clase implementada en Java, facilita el trabajo con estructuras contenedoras. Algunos de sus métodos se
presentan a continuación.
Método Descripción
static boolean equals (int[ ] a,int[ ] a2) Devuelve true si los arreglos tienen los mismos
elementos, en el mismo orden
if(Arrays.equals(miArreglo1, miArreglo2))
static int[ ] copyOf (int[ ] original, int newLength); Copia el arreglo original (trunca o rellena para que el
resultado quede con el tamaño requerido).
resultado = Arrays.copyOf(miArreglo1, 4);

static int[ ] copyOfRange(int[] original, int from, int to) Copia el arreglo original, desde la posición inicial hasta
la final
static void fill (int[ ] a, int val) Rellena con val cada elemento del arreglo de enteros.
static void fill (int[ ] a, int inicio, int final, int val) Arrays.fill(miArreglo1, 5);
La segunda opción permite especificar el rango de

posiciones en la que se va a efectuar el reemplazo
static String toString(int[] a) Retorna la representación en String del contenido del
arreglo
Tabla 16 Métodos de la clase Arrays
100
4.4 Métodos estándar usados en esta unidad: leerArregloEnteros, leerArregloDouble
Los siguientes métodos son de uso común a lo largo de la unidad 7.
/** /**
* Método para leer varios enteros y retornarlos en un * Método para leer varios numeros y retornarlos en un
arreglo arreglo
* *
* @param mensaje Mensaje mostrado al usuario * @param pregunta Texto que se muestra al usuario
* @param cantidad Cantidad de textos a ingresar * @param num Cantidad de elementos a leer
como respuesta * @return Arreglo con la informacion ingresada por el
* @return Arreglo con los textos ingresados como usuario
respuesta */
*/ public static double[] leerArregloDouble ( String
public static int[] leerArregloEnteros ( String mensaje, pregunta, int num )
int cantidad ) {
{ double arreglo[]= new double [ num ];
int i, enteros[]; for ( int i = 0 ; i < num ; i++ )
enteros = new int [ cantidad ]; {
for ( i = 0 ; i < cantidad ; i++ ) arreglo [ i ] = leerDouble( pregunta +
{ "( " + (i+1) + " de " + num + " )" );
enteros [ i ] = leerEntero( mensaje + }
"( " + (i+1) + " de " + cantidad + " )" ); return arreglo;
} }
return enteros;
}
/**
* Método que imprime varios enteros dados en un
arreglo
*
* @param cadenas Representación en String del
arreglo
*/
public static String devolverStringArreglo ( int[]
arreglo )
{
String salida;
salida = "[";
for ( int i = 0 ; i < arreglo.length ; i++ )
{
salida += arreglo[ i ] + " ";
}
salida +="]";
return ( salida );
}
Ejemplo 17 Dado un arreglo de Strings, crear uno nuevo en el que los elementos queden en orden inverso
El método leerVectorString permite ingresar cada uno de los elementos del vector de Strings, para ello requiere que
se le envíe como argumento el tamaño del arreglo.
El método invertir recibe el arreglo y se encarga, haciendo uso de un for, de ir llenando un arreglo auxiliar, que tiene
el mismo tamaño del arreglo ingresado por el usuario. El for recorre el arreglo original desde la última posición hasta
la posición 0.
A continuación se plantean dos posibles implementaciones del método invertir. La primera de ellas, hace uso
únicamente del índice i, mientras que la segunda utiliza un segundo índice llamado j.
7
Basado en el material de clase del profesor Julián Esteban Gutiérrez
101
La aplicación completa se presenta en el Programa 17.
public static String[] invertir ( String[] vector ) public static String[] invertir ( String[] vector )
{ {
String[] salida; String[] salida;
int i; int i;
salida = new String [ vector.length ]; salida = new String [ vector.length ];
for ( i = vector.length-1 ; i >=0 ; i-- ) int j=0;
{ for ( i = vector.length-1 ; i >=0 ; i-- )
salida [vector.length - 1 - i] = vector[ i ]; {
} salida [j] = vector[ i ];
return salida; j++;
} }
return salida;
}
Programa 17 Invertir
/**
* Programa que invierte un arreglo
*
* @author sonia
* Los métodos leerDouble, leerEntero, leerChar, leerString, leerBoolean, leerArregloDouble,
* leerArregloEnteros, leerArregloString e imprimir son basados en el material del profesor
* Julián Esteban Gutierrez de la U. del Quindio
*/
public class Inversion {
/**
* @param args los argumentos de la línea de comando
*/
public static void main ( String[] args ) {
int n;
String[] vector, inverso;
n = leerEntero( "Cantidad de palabras: " );

vector = leerVectorString ( "palabra: ", n );
inverso = invertir( vector );
imprimir( "El vector original:" +(Arrays.toString(vector)) +

"\nEl arreglo en orden inverso: "+imprimirVector(inverso));
/**
* Método que recibe un arreglo de cadenas y retorna otro arreglo con los
* textos en orden inverso
*
* @param vector Arreglo de strings
* @return El arreglo en orden inverso.
*/
public static String[] invertir ( String[] vector )
102
{
String[] salida;
int i;
salida = new String [ vector.length ];
for ( i = vector.length-1 ; i >=0 ; i-- )

{
salida [vector.length - 1 - i] = vector[ i ];
}
return salida;
}
/**
*/
{
return dato;
}
/**
*/
{
}
/**Imprime los elementos del vector
* @param arreglo
* @return Un string con la representacion del vector
*/
public static String imprimirVector ( String[] arreglo)
{
String salida="[";
String aux=", ";
for (int i = 0 ; i < arreglo.length ; i++ )

{
if(i==arreglo.length-1)
{ aux=" ";}
salida += arreglo[ i ] + aux;
}
salida+=" ]";
return salida ;
}
/**
* Permite leer un vector de Strings
* @return el vector de Strings
*/
public static String[] leerVectorString (String mensaje, int tam)
{
String dato;
103
String[] arreglo= new String[tam];
{
dato=JOptionPane.showInputDialog(mensaje+" "+i);
arreglo[ i ] = dato;
}
return arreglo;
}
Ejecución
Ejemplo 18 Promedio
Esta aplicación considera varios requisitos funcionales:
a. Leer un vector de números

b. Calcular el promedio de los elementos de un vector
c. Informar la cantidad de elementos que exceden el promedio
El método calcularPromedio, recibe una arreglo y recorre cada una de sus posiciones mediante un for. A medida que
se va moviendo se acumula en la variable promedio el valor almacenado en cada posición. Luego de que el for
finaliza promedio se divide entre la cantidad de elementos del arreglo.
104
El método obtenerCantidadExcedePromedio, recibe un vector de tipo entero. El método inicia invocando el método
calcularPromedio. A continuación mediante una estructura repetitiva se recorre el vector y cada uno de los elementos
se compara con el promedio previamente calculado. Si es superior, se incrementa un contador. Finalmente, se
devuelve el valor del contador.
Programa 18 Promedio
/**
* Programa que dado un vector con n elementos,
* informe la cantidad de elementos que exceden el promedio.
*
* @author sonia
*/
public class Promedio {
/**
* @param args los argumentos de la linea de comandos
*/
int cantidad;
double datos[];
double promedio;
int resultado;
cantidad = leerEntero ( "Ingrese la cantidad de elementos" );

datos = leerArregloDouble ( "Ingrese un número", cantidad );
promedio = calcularPromedio ( datos );
resultado=obtenerCantidadExcedePromedio(datos);
imprimir( "El promedio es: " + promedio +
"\nLa cantidad de elementos que exceden el promedio es: "+resultado);
}
/**
* Método que calcula el promedio de un arreglo
*
* @param arreglo Arreglo de números
* @return El promedio de los números contenidos en el arreglo
*/
public static double calcularPromedio ( double arreglo[] )
{
double promedio;
promedio = 0;

{
promedio = promedio + arreglo [ i ];
}
promedio = promedio/ arreglo.length ;
return promedio;
}
105
public static int obtenerCantidadExcedePromedio(double datos[])
{
int contador;
contador = 0;
double promedio= calcularPromedio ( datos );
for ( int i = 0 ; i < datos.length ; i++ )

{
if(datos[i]>promedio)
{
contador++;
}
}
return contador;
}
/**
*/

{
return dato;
}
/**
*/
{
return dato;
}
/**
* Método para leer varios numeros y retornarlos en un arreglo
*
* @param pregunta Texto que se muestra al usuario
* @param num Cantidad de elementos a leer
* @return Arreglo con la informacion ingresada por el usuario
*/
public static double[] leerArregloDouble ( String pregunta, int num )
{
double arreglo[]= new double [ num ];
for ( int i = 0 ; i < num ; i++ )

{
arreglo [ i ] = leerDouble( pregunta +
"( " + (i+1) + " de " + num + " )" );
}
106
return arreglo;
}
/**
*/
{
}
Ejecución
Ejemplo 19 Operaciones sobre un vector
Esta aplicación considera varios requisitos funcionales. Ingresar un vector de números y:
a. Obtener un nuevo vector con los elementos del arreglo origina que corresponden a la opción
elegida por el usuario (0 pares, 1 impares)
b. Concatenar dos arreglos
Para resolver el requisito funcional a, se implementa el método obtenerElementos, que tiene dos parámetros. El
primero de ellos, corresponde al vector de datos y el segundo, es la opción elegida por el usuario (0  pares, 1
impares). De acuedo a la opción ingresada, se calcula mediante el método obtenerCantidad, la cantidad de
elementos que tendrá el vector resultante y haciendo uso de un for se va llenando este vector.
107
Para el requisito funcional b, se construye el método concatenar, que tiene como parámetros a los dos arreglos que
se van a unir, dando como resultado un nuevo vector, que tendrá como tamaño la suma de las longitudes de los dos
vectores originales. Dentro del for se evalua si el índice i es menor que la longitud del arreglo1, en tal caso se copian
todos los elementos del arreglo1 al arregloResultante en la posición i. Si está condición no se cumple, es decir, i>=
arreglo1.length, se utiliza un índice auxiliar j para ubicar los elementos del segundo vector en el arregloResultante,
en la posición correcta.
Programa 19 Vector
/** @author sonia

*/
public class Vector {
/**
*/
int cantidad, enteros[], pares[], impares[], resultado[];
String informacion = "";

cantidad = leerEntero( "Cantidad de números a leer" );
enteros = leerArregloEnteros( "Ingrese un entero ", cantidad );
//si se ingresa 0 se obtienen los pares, si se ingresa 1 los impares

pares = obtenerElementos ( enteros, 0 );
impares = obtenerElementos ( enteros, 1 );
resultado = concatenar (pares, impares);
informacion+= "Original: \n" + devolverStringArreglo( enteros );

informacion+= "\nPares: \n" + devolverStringArreglo( pares );
informacion+= "\nImpares: \n" + devolverStringArreglo( impares );
informacion+= "\nResultante: \n"+ devolverStringArreglo( resultado);
imprimir(informacion);
/**
* Método para obtener sólo los números pares o impares de un arreglo de enteros, dependiendo
* de la variable opcion
*
* @param datos Arreglo con los datos
* @return Una parte del arreglo original que contiene los pares (opcion==0) o los impares (opcion==1)
*/
public static int[] obtenerElementos ( int[] datos, int opcion )
{
int elementos[], i, j, cantidad;
j = 0;
cantidad = obtenerCantidad ( datos, opcion );
108
elementos = new int [ cantidad ];
for ( i = 0 ; i < datos.length ; i++ )

{
//Si la opcion es cero el dato debe ser par
if ( datos[ i ] % 2 == 0 &&opcion==0 )
{
elementos [ j ] = datos [ i ];
j++;
}
else
//Si la opcion es uno el dato debe ser impar
if (datos[ i ] % 2 != 0 &&opcion==1)
{
elementos [ j ] = datos [ i ];
j++;
}
}
return elementos;
}
/**
* Concatena dos arreglos, es decir, une dos arreglos
* @param arreglo1 El primer arreglo, arreglo1!=null
* @param arreglo2 El segundo arreglo, arreglo2!=null
* @return El resultado de la concatenacion
*/
public static int[] concatenar (int[] arreglo1, int[] arreglo2)

{
int arregloResultante[] = new int[arreglo1.length+arreglo2.length];
int j = 0;
for(int i=0; i<arreglo1.length+arreglo2.length; i++)

{
if(i<arreglo1.length)
{
arregloResultante[i]=arreglo1[i];
}
else
{
arregloResultante[i]=arreglo2[j];
j++;
}
}
return arregloResultante;
}
/**
* Método que cuenta la cantidad de pares o impares que hay en un arreglo de enteros
*
* @param enteros Arreglo de números enteros
* @return La cantidad de números pares en el arreglo
*/
public static int obtenerCantidad ( int[] enteros, int opcion )
109
{
int cantidad=0;
for (int i = 0 ; i < enteros.length ; i++ )

{
if ( enteros[ i ] % 2 == 0 &&opcion==0)
{
cantidad++;
}
else
if ( enteros[ i ] % 2 != 0 &&opcion==1)
{
cantidad++;
}
return cantidad;
}
/**
*
*/
{
}
/**
*
*/
{
}
/**
* Método para leer varios enteros y retornarlos en un arreglo
* @param mensaje Mensaje mostrado al usuario
* @param cantidad Cantidad de textos a ingresar como respuesta
* @return Arreglo con los textos ingresados como respuesta
*/
public static int[] leerArregloEnteros ( String mensaje, int cantidad )
{
int i, enteros[];
enteros = new int [ cantidad ];
for ( i = 0 ; i < cantidad ; i++ )

{
enteros [ i ] = leerEntero( mensaje +
"( " + (i+1) + " de " + cantidad + " )" );
}
110
return enteros;
}
/**
* Método que imprime varios enteros dados en un arreglo
*
* @param cadenas Representación en String del arreglo
*/
public static String devolverStringArreglo ( int[] arreglo )
{
String salida;
salida = "[";
{
salida += arreglo[ i ] + " ";
}
salida +="]";
return ( salida );
}
}
Ejecución
111
Ejemplo 20 Eliminar el elemento del vector que está en la posición indicada
Esta aplicación solicita un vector a un usuario y una posición p, y crea un nuevo vector con todos los elementos,
excepto el que está en la posición p. El método eliminar, es el encargado, de implementar dicha funcionalidad, para
ello requiere dos parámetros, el arreglo y la posición. El proceso de eliminación se realiza haciendo uso de una
estructura repetitiva, en la que por cada iteración se verifica si el índice i es diferente de la posición que desea
eliminar el usuario, en tal caso se copia el elemento en un arreglo auxiliar. De lo contrario, no se efectúa ninguna
operación.
Programa 20 Eliminación
/** @author sonia

*/
public class Eliminacion{
/**
*/
public static void main( String[] args) {
int cantidad, arreglo[], resultante[], posicion;
cantidad = leerEntero ( "Indique la cantidad de elementos a leer");

arreglo = leerArregloEnteros( "Ingrese el elemento ", cantidad );
posicion = leerEntero ( "Ingrese un número ");
resultante = eliminar ( arreglo, posicion );
imprimir( "Arreglo original: "+Arrays.toString(arreglo)+

"\nArreglo sin el elemento: "+Arrays.toString(resultante));
/**
* Método para eliminar que esta en la posicion indicada por el usuario de un arreglo
112
*
*
* @param arreglo Arreglo de enteros
* @param posicion posicion del elemento a eliminar
* @return El arreglo sin el elemento
*/
public static int[] eliminar ( int[] arreglo, int posicion )
{
int resultante[]= new int [ arreglo.length - 1 ];
int j=0;
/*Se debe manejar un nuevo indice, j, porque el vector
resultante no se llena a la misma velocidad que se recorre
el arreglo original (hay una diferencia de un elemento entre ambos),
esto se refleja en la instruccion, resultante [ j ] = arreglo [ i ];
*/

{
if ( i != posicion )
{
resultante [ j ] = arreglo [ i ];
j++;
}
}
return resultante;
}
/**
*
*/
{
}
/**
* Método para imprimir un texto .
*
*/
{
}
/**
*
*/
113
{
int i, enteros[];

{
"( " + (i+1) + " de " + cantidad + " )" );
}
return enteros;
}
}
Ejecución
114
Ejemplo 21 Conjuntos
Esta aplicación permite realizar operaciones entre 2 conjuntos. Se debe permitir:
a. Ingresar los conjuntos

b. Hallar la unión entre dos conjuntos
c. Hallar la intersección entre los dos conjuntos
Para hallar la unión se implementa previamente el método isContenido, que dado un vector y un String, devuelve
true si la cadena está contenida en alguna posición del vector.
El método hallarUnion tiene como parámetros a dos vectores de Strings. El primer paso que se realiza es copiar en
el vector resultante todos los elementos del primer vector. Luego, se recorre el segundo vector y, por cada uno de
sus elementos, se verifica que no este contenido en el vector resultante, si es así se agrega, de lo contrario se
descarta.
El método hallarInterseccion recorrre el conjunto1 y por cada uno de sus elementos verifica si está contenido en el
conjunto2, si es así, lo agrega al vector resultante. Esta operación requiere el uso de un índice (contador) que permita
almacenar el elemento en la posición correcta.
Programa 21 Conjuntos
/**
* Dados dos conjuntos hallar la unión e intersección.
*
* @author sonia
*/
public class Conjuntos{
/**
* @param args los argumentos de la linea de comandos
*/
String conjunto1[], conjunto2[], union[], interseccion[];
conjunto1 = leerString( "Ingrese los elementos del primer conjunto separados por coma").split(",");
conjunto2 = leerString( "Ingrese los elementos del segundo conjunto separados por coma ").split(",");
union = hallarUnion (conjunto1, conjunto2);

interseccion = hallarInterseccion(conjunto1, conjunto2);
imprimir( "Conjunto1 :\n"+ Arrays.toString (conjunto1) +

"\nConjunto2 :\n"+ Arrays.toString (conjunto2) +
"\nUnion :\n"+ Arrays.toString(union) +
"\nInterserccion :\n"+ Arrays.toString (interseccion));
/**
115
* Halla la union de dos conjuntos
* @param conjunto1 El conjunto 1
* @param conjunto2 el conjunto 2
* @return La union de los dos conjuntos
*/
public static String[] hallarUnion(String conjunto1[], String conjunto2[])
{
String resultado[]=new String[conjunto1.length + conjunto2.length];
int contador = 0;
String dato = "";
//se copia primero el primer vector

for(int i=0; i<conjunto1.length; i++)
{
resultado [contador] = conjunto1 [i];
contador ++;
}

{
dato=conjunto2 [i];
if(isContenido(resultado, dato) == false)
{
resultado [contador] = dato;
contador ++;
}
}
//Se eliminan los espacios en null
resultado=Arrays.copyOf(resultado, contador);
return resultado;
}
/**
* Halla la interseccion de dos conjuntos
* @param conjunto1 El conjunto 1
* @param conjunto2 eE l conjunto 2
* @return La interseccion de los dos conjuntos
*/
public static String[] hallarInterseccion(String conjunto1[], String conjunto2[])
{
String resultado[];
int tamMaximo=conjunto1.length;
int contador = 0;
String dato = "";
//se halla el tamaño maximo del conjunto

if(conjunto2.length>tamMaximo)
{
tamMaximo = conjunto2.length;
}
resultado= new String[tamMaximo];
//se verifica si un elemento está en ambos conjuntos

{
dato = conjunto1 [i];
if(isContenido(conjunto2, dato))
116
{
resultado [contador] = dato;
contador ++;
}
}
//Se eliminan los espacios en null

resultado=Arrays.copyOf(resultado, contador);
return resultado;
}
/**
* Verifica si dato está contenido en el arreglo
* @param conjunto El arreglo de elementos
* @param dato El dato a buscar
* @return Un true si se encuentra en el arreglo, false en caso contrario
*/
public static boolean isContenido(String conjunto[], String dato)

{
for(int i=0; i < conjunto.length && centinela == false; i++)
{
if(conjunto[i]!=null&& (conjunto[i].trim()).equals(dato.trim()))
{
centinela = true;
}
}
return centinela;
}
/**
* Método para eliminar un elemento de un vector
*
* @param arreglo Arreglo de enteros
* @param posición Posición a eliminar
* @return Un nuevo arreglo sin el elemento de la posición dada
*/
public static int[] eliminarElemento ( int[] arreglo, int posicion )
{
int nuevoArreglo[]= new int [ arreglo.length - 1 ];
int j=0;
{
if ( i != posicion )
{
nuevoArreglo [ j ] = arreglo [ i ];
j++;
}
}
return nuevoArreglo;
}
117
/**
*
*/
{
}
/**
* Método para imprimir un texto en una caja de dialogo.
*
* @param texto Texto que se desea mostrar
*/
{
}
/**
*
*/
{
int i, enteros[];
{
enteros [ i ] = leerEntero( mensaje + "( " + (i+1) + " de " + cantidad + " )" );
}
return enteros;
}
/**
* Método para leer un String
*
* @return El texto ingresado
*/
public static String leerString ( String mensaje )
{
return JOptionPane.showInputDialog( mensaje );
}
}
118
Ejecución
Ejemplo 22 Fusionar dos arreglos
Esta aplicación fusiona dos arreglos. El proceso seguido es el siguiente, el arreglo 1 se recorre de izquierda a
derecha y el arreglo 2 de derecha a izquierda. Ambos vectores deben tener la misma longitud. Por ejemplo, si se
tienen los siguientes arreglos:
arreglo1
1 2 3 4
arreglo2
5 6 7 8
El arreglo resultante es:
1 8 2 7 3 6 4 5
El método fusionar tiene dos parámetros: arreglo1 y arreglo2. Para realizar la fusión se hace uso del índice i (que
permite recorrer el arreglo1) y del índice j (para recorrer el arreglo2). La variable j inicia en la última posición del
arreglo2. Por cada iteración del ciclo se almanenan dos valores en el vector resultado, mediante las instrucciones
resultado[contador] = arreglo1 [i] y resultado[contador] = arreglo2 [j]. Observe que mientras que la i incrementa,
la j decrementa.
119
Programa 22 Fusionar arreglos
/** @author sonia

*/
public class Fusion{
/**
*/
int arreglo1 [], arreglo2 [];
int cantidad;
int fusion [];
cantidad = leerEntero("Ingrese la cantidad máxima de elementos ");

arreglo1 = leerArregloEnteros("ARREGLO 1: Ingrese el elemento ", cantidad);
arreglo2 = leerArregloEnteros("ARREGLO 2: Ingrese el elemento ", cantidad);
fusion = fusionar (arreglo1 , arreglo2);
imprimir("Arreglo 1: \n"+Arrays.toString(arreglo1)+
"\nArreglo 2: \n"+Arrays.toString(arreglo2)+
"\nArreglo fusionado: \n"+Arrays.toString(fusion));
}
/**
* Se fusionan dos vectores, el arreglo 1 se recorre de izquierda a derecha
* y el arreglo 2 de derecha a izquierda
* @param arreglo1 El arreglo 1
* @param arreglo2 El arreglo 2
* @return El arreglo resultado de la fusion
*/
public static int [] fusionar(int arreglo1 [], int arreglo2[])

{
int [] resultado = new int [arreglo1.length + arreglo2.length];
int j = arreglo2.length-1;
int contador = 0;
for(int i=0; i<arreglo1.length; i++)

{
resultado[contador] = arreglo1 [i];

contador++;
resultado[contador] = arreglo2 [j];
contador++;
j--;
}
return resultado;
}
120
/**
*
*/
{
int i, enteros[];
{
"( " + (i+1) + " de " + cantidad + " )" );
}
return enteros;
}

*/
{
return dato;
}
/**
* Método para imprimir un texto en una caja de dialogo
*
* @param mensaje Texto que se desea mostrar
*/
public static void imprimir( String mensaje)
{
JOptionPane.showMessageDialog( null, mensaje);
}
Ejecución
121
Ejemplo 23 Eliminar repeticiones de un arreglo
Esta aplicación solicita un vector al usuario y si tiene elementos repetidos deja solamente una ocurrencia. Ejemplo,
si se tiene el siguiente vector:
1 2 1 1 2 4 5 4 2
El resultado será:
1 2 4 5
El método eliminarRepetidos recibe un vector y crea uno nuevo con el mismo tamaño, llamado resultado. Mediante
una estructura repetitiva se recorre el vector original, y se obtienen uno a uno sus elementos. Por cada elemento,
se verifica si está contenido en el vector resultado. Si no está contenido, se almacena en la posición contador, del
vector resultado.
122
Programa 23 Repeticiones
/** @author sonia

*/
public class Repeticion {
/**
*/
String datos[], datosSinRepeticiones[];
datos = leerString( "Ingrese los elementos del vector a examinar, separados por coma").split(",");
datosSinRepeticiones = eliminarRepetidos (datos);
imprimir ( "Original: \n"+ Arrays.toString (datos) +

"\nSin Repeticiones:\n"+ Arrays.toString ( datosSinRepeticiones) );
/**
* Método para eliminar los elementos repetidos de un arreglo
* @param original El arreglo original
* @return El arreglo sin repeticiones
*/
public static String[] eliminarRepetidos (String [] original)
{
String resultado[]= new String[original.length];
String cadena = "";
int contador = 0;
for(int i=0; i<original.length; i++)

{
cadena = original [i];
if(!verificarEstaContenido(resultado, cadena ))
{
resultado [contador] = cadena;
contador++;
}
resultado = Arrays.copyOf(resultado, contador);
return resultado;
/**
* Verifica si dato está contenido en el arreglo
* @param vector El arreglo de elementos
123
* @param dato El dato a buscar
* @return Un true si se encuentra en el arreglo, false en caso contrario
*/
public static boolean verificarEstaContenido(String vector[], String dato)

{
for(int i=0; i < vector.length && vector[i]!=null && centinela == false; i++)
{
if(vector[i]!=null&&vector[i].trim().equals(dato.trim()))
{
centinela = true;
}
}
return centinela;
}
/**
*
*/
{
}
/**
* Método para imprimir un texto en una caja de dialogo
*
* @param mensaje Texto que se desea mostrar
*/
public static void imprimir( String mensaje)
{
JOptionPane.showMessageDialog( null, mensaje);
}
}
124
Ejemplo 24 Obtiene la cantidad de vocales en un String
Esta aplicación informa la cantidad de vocales que hay en un String 8. Para resolver este requisito funcional se
implementarán dos métodos, el primero de ellos, isVocal. Este método recibe un caracter (si está en minúscula lo
pasa a mayúscula) y lo compara con cada una de las vocales.
El método contar vocales,recorrre el vector de char y por cada vocal invoca al método isVocal, si éste último retorna
true, se incrementa el contador.Finalmente se retorna el valor del contador.
Programa 24 Contar vocales
/** @author sonia

*/
public class Operacion {
/**
*/
String nombre;
int cantidadVocales;
nombre = leerString( "Ingrese un nombre: ");
if(nombre!=null)
{
cantidadVocales=contarVocales(nombre);
imprimir("La cantidad de vocales es "+cantidadVocales);
}
else
{
imprimir("Ingrese un nombre valido");
}
}
/**
* Obtiene la cantidad de vocales en un String
* @param nombre Es el nombre ingresado por el usuario, nombre!=null
* @return La cantidad de vocales
*/
public static int contarVocales (String nombre)
{
int contador=0;
char arreglo[]= nombre.toCharArray();
for(int i=0; i<arreglo.length; i++)

{
if(isVocal(arreglo[i]))
{
contador++;
}
}
return contador;
8
Dado que el tema de operaciones sobre cadenas no está contemplado dentro del contenido del espacio académico de
Paradigma orientado a objetos de la universidad del Quindío, se seguirá la estrategia de pasar el String a un vector de char.
125
}
/**
* Recibe la letra
* @param letra Es la letra a verificar
* @return Un boolean, true si es vocal, false en caso contrario
*/
public static boolean isVocal(char letra)
{
if(letra>='a'&&letra<='z')
{ //se pasa a mayuscula
letra=(char) (letra-32);
}
if(letra=='A'||letra=='E'||letra=='I'||letra=='O'||letra=='U')
{
centinela=true;
}
return centinela;
}
/**
*
*/
{
}
/**
*
*/
{
}
4.5 Taller de arreglos
1. Obtener el promedio de todos los números primos que hay en un arreglo.
2. Obtener el promedio de todos los números perfectos que hay en un arreglo. Un número es perfecto
cuando la suma de sus divisores propios es igual al mismo número. Ejemplo 6 es número perfecto,
porque sus divisores propios son 1, 2 y 3; y 6 = 1 + 2 + 3.
3. Programa para hallar la diferencia entre dos conjuntos.

126
4. Pasar de decimal a hexadecimal, almacenar el resultado en un vector.
5. Leer dos vectores A y B, e indicar si el uno está contenido en otro en orden estricto inverso
Ejemplo A= 1,2,3,4,5,7 B=5,4,3 Debe indicar que B está contenido en A
6. Desarrollar un método que permita determinar los tres valores que más se repiten en un
vector de n elementos enteros.
Para los siguientes puntos no use métodos de la clase String. En su lugar convierta el String en una cadena de
caracteres, para ello use toCharArray.
7. Dado un arreglo de Strings de n elementos, y un String k, genere un segundo arreglo con todas las posiciones
en donde el String k (o el String en orden inverso) está almacenado en el primer arreglo 9.
k = “hola”
0 1 2 3 4 5
hola pepe hola a aloh te
1 2 4
8. Leer un arreglo de Strings y suprimir todas las consonantes de cada de unas palabras contenidas.
9. Dado un arreglo de Strings de n elementos, genere e imprima un nuevo arreglo con los elementos en orden
descendente. Para resolver este punto, investigue e implemente un método de ordenamiento llamado “Burbuja”.
No puede usar la clase Arrays.
10. Dado un String, crear uno nuevo que contenga primero las vocales y luego las consonantes.
Ejemplo: “ensayo”
eaonsy
11. Leer un arreglo de Strings y una cadena. Informar la posición dentro del arreglo del String que contenga más
veces la cadena leída.
Cadena= hola
Arreglo= mariahola, holaholahola, pepehola, rolaholaholahola
Posición = 3
9
Enunciado basado parcialmente en material del profesor Julián Esteban Gutiérrez
127
128
Índice
Análisis, 11 long, 13
argumento, 37 método, 36
Arrays, 100 montículo, 15
arreglos, 97 new, 97
byte, 13 objeto, 15
bytecode, 11 operador decremental, 18
casting, 26 operador incremental, 18
clase, 15 Operadores aritméticos, 18
clases envoltorio, 15 Operadores lógicos, 27
Constantes, 15 Operadores relacionales, 28
contrato de un método, 38 parámetros, 36
depurador, 68 Patrón de doble recorrido, 99
diseño, 11 Patrón de Recorrido Parcial, 99
do while, 67 Patrón de recorrido Total, 98
double, 13 pila, 15
Estructuras repetitivas, 67 prioridad de operadores, 19
excepción, 38 requisitos funcionales, 11
expresión, 18 requisitos no funcionales, 11
float, 13 short, 13
for, 67 stack, 15
heap, 15 String, 16
identificador, 12, 17, 36 switch, 58
if, 49 Tipos de datos por referencia, 15
implementación, 11 Tipos de datos primitivos, 13
int, 13 while, 67
129
130
Referencias
[1] P. Novara, «PSeInt,» 2017. [En línea]. Available: http://pseint.sourceforge.net.
[2] J. VILLALOBOS y R. CASALLAS, «Fundamentos de Programación – Aprendizaje Activo Basado en Casos. .

Edición digital, 2010.,» [En línea]. Available: https://cupi2.virtual.uniandes.edu.co/guia-estudiante-apo1.
[3] P. Sánchez, «Consejos y Buenas Prácticas en Programación,» 2010. [En línea]. Available:
http://personales.unican.es/sanchezbp/teaching/faqs/programming.html.
[4] The JUnit Team, «JUnit 5,» 2017. [En línea]. Available: http://junit.org/junit5/.
[5] Microsoft, «Tipos de referencia y de valor,» 2017. [En línea]. Available: https://msdn.microsoft.com/es-
co/library/4d43ts61(v=vs.90).aspx.
[6] Disfruta Las Matemáticas.com, «Sectores y segmentos de círculos,» 2011. [En línea]. Available:
http://www.disfrutalasmatematicas.com/geometria/circulos-sectores-segmentos.html.
[7] Rekkeb Blog, «Curiosidades Java: Break y Continue,» 2009. [En línea]. Available:
https://rekkeb.wordpress.com/2009/04/11/curiosidades-java-break-y-continue/.
[8] Santillana, «Áreas de figuras planas,» [En línea]. Available:

http://www.sectormatematica.cl/basica/santillana/areas.pdf.
[9] ARNOW, David y WEISS, Gerald. Introducción a la programación con Java. Edición 3ª Madrid:
Addison Wesley, 2001.
[10] SCHILDT, Herbert. Fundamentos de programación en Java 2. Edición 1ª. Bogotá: McGraw-Hill,
2001.
[11]SCHILDT, Herbert. Java 2 manual de referencia. Cuarta Edición. Madrid: McGrawHill, 2001.
[12] SCHILDT, Herbert. Java 2 the complete reference. Fourth Edition. Berkeley: McGraw-Hill, 2001.
[13] WEISS, Mark. Estructuras de datos en Java. Edicion 1ª Adison Wessley 2000
[14] NAUGTHTON, Patrick. Java Manual de Referencia. Edicion 2ª McGraw- Hill 1997
[15] DEITEL, Paul J. y DEITEL, Harvey M. Como programar en Java 7ª edición. Pearson Education,
México 2008.
[16] DEITEL, Paul J. y DEITEL, Harvey M. Java how to program 9ª. Prentice Hall, 2012.
[17]HORSTMANN, Cay. Java concepts 5ª. John Wiley & Sons, Inc.
[18]ECKEL, Bruce. Piensa en Java 4ª. Pearson Education S.A. Madrid 2007.
131
132
ANEXO 1. Tabla de códigos UNICODE
Tabla tomada de [2]
133
134
ANEXO 2. PSeInt
PSeInt es una herramienta para crear pseudocodigo y diagramas de flujo creada por Pablo Novara. Para su uso,
descargue el instalador de la dirección resaltada en el siguiente gráfico.
Luego ejecute la aplicación descargada y siga el proceso de instalación.
Cuando este proceso finalice, ingrese al PSeInt e de clic en opciones del lenguaje y luego en Personalizar.
Active la opción “permitir asignar con el signo igual (=)” y “controlar el uso de ; al final de las sentencias
secuenciales“ y desactive obligar a definir los tipos de variables
135
PSeInt permite hacer uso de comando graficos. Se destacan los comandos Escribir, Leer y Asignar. Escribir sirve
para mostrar (imprimir) el resultado de una operación. Por ejemplo si se tienen dos números, se calcula una suma
y se quiere mostrar el resultado. También sirve para mostrar un mensaje cualquiera, por ejemplo un saludo. El
comando leer permite inicializar una variable con los datos dados por el usuario. El proceso de lectura se efectúa
cuando el usuario debe ingresar datos para realizar una operación. Por ejemplo, si se quieren sumar dos números a
y b, el usuario debe ingresar “a”, luego ingresar “b” para luego sí poder hacer el cálculo. El comando asignar permite
cambiar el valor de una variable. La lectura es una operación de entrada (pues se le piden datos al usuario) y la
escritura es una operación de salida (se le muestra información al usuario).
136
Según se define en la ayuda del PSeInt, esta aplicación cuenta con los siguientes operadores:
Para crear una primera aplicación en PSeInt de clic en File Nuevo. Asigne nombre a la aplicación, en este caso
se le da el nombre de programa_1
137
Algoritmo Programa_1
a = 9;
b = 6;
resultado = a ^ (1/2.0);
resultado2 = b ^ (1/2.0);
Escribir resultado;
Escribir resultado2;
FinAlgoritmo
Para ejecutar presione el botón ejecutar ( )
Para ver el diagrama de flujo de clic sobre el botón
Algunos ejemplos de diagrama de flujo y pseudocodigo se presentan a continuación.
Algoritmo para calcular el área de un triángulo
138
Convertir de metros a centímetros
Calcule el porcentaje de hombres y el porcentaje de mujeres que hay en un salón de clases
Calcular el nuevo precio de un artículo que se ha incrementado en un 15%
139
En países de habla inglesa la estatura se expresa en pies y pulgadas, por ejemplo 3’ 2”. Construya un algoritmo
para convertir a metros. 1 pie= 12 pulgadas, 1 pulgada=2.54 cm, 1m=100 cm
calcular la suma de las cifras de un número de 4 cifras
140
Una función es un conjunto de instrucciones que permiten resolver un problema particular. Está compuesto por un
retorno, un nombre y unos parámetros.
Para crear un metodo presione sobre el comando Funcion o Subproceso.
Una función tiene la siguiente estructura

SubProceso variable_de_retorno <- Nombre ( Argumentos )
//cuerpo del metodo
FinSubProceso
Funcion variable_de_retorno <- Nombre ( Argumentos )

//cuerpo del metodo
FinFuncion
A continuación se presentan algunos ejemplos de aplicaciones que hacen uso de subprocesos o funciones.
Calcular el área de un rectangulo
141
Convertir de fahr a centígrados
142
Calcular sumatoria de 1 a n
Calcula el factorial
143
144
ANEXO 3. Instalación de Eclipse
1) Digite en su navegador Oracle jdk y de clic en buscar.Elija Java SE Development Kit Downloads Oracle
2. A continuación acepte los términos de la licencia y elija la versión para Windows de 64 bits (o la requerida por su
equipo)
2. Luego de que descargue, de clic en ejecutar. A continuación de clic en siguiente (varias veces hasta finalizar
el proceso de instalación).
145
3. Ingrese a la siguiente dirección: https://eclipse.org/downloads/ De clic sobre Get Eclipse Neon -64 bits
146
4. Seleccione Download. Luego de que el archivo se ha descargado, ejecute el instalador
147
8. La siguiente pantalla será desplegada. Seleccione: eclipse IDE for Java Developers
9. De clic en Instalar.
148
10. Eclipse quedará instalado en la ruta mostrada en la captura de pantalla anterior. De clic en Launch
11. Ahora se agrega el WindowBuilder, para facilitar la creación de interfaces gráficas. Para ello de clic en Help-
> Install New Software
149
12. Agregue la ruta siguiente ruta en Work with: http://download.eclipse.org/windowbuilder/WB/integration/4.6/
De clic en Add (Recuerde poner nombre le nombre al repositorio WindowBuilder) y active la casilla
WindowBuilder.
13. Luego de clic en Siguiente.

150
14. Acepte los términos de la licencia.
15. De clic en OK
151
152
153

Libroparadigma2017 FINAL2 Caratula

Cargado por

Copyright:

Formatos disponibles

Libroparadigma2017 FINAL2 Caratula

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Libroparadigma2017 FINAL2 Caratula

Cargado por

Copyright:

Formatos disponibles

1

Sonia Jaramillo Valbuena

Programa de Ingeniería de Sistemas y Computación

Universidad del Quindío

Sergio Augusto Cardona Torres

Programa de Ingeniería de Sistemas y Computación

Universidad del Quindío

Luis Fernando Castro

Programa de Ingeniería de Sistemas y Computación

Universidad del Quindío

 Comprender y seguir el proceso para resolver un programa de computador haciendo uso

Figura 1Proceso de solución de un problema, basado en [2]

Ejemplos de identificadores válidos son:

varX PI MAX_NUM dirección

Nombre Rango de valores Tamaño en bits Declaración

byte -128 a 127 8 byte var1=4;

short -32768 a 32767 16 short var2

int -2147483648 a 2147483647 32 int var3;

long -9223372036854775808 a 9223372036854775807 64 long var4;

Tabla 1 Tipos de datos enteros

float 3,4E-38 a 3,4E38 32 float num1 = 2.7182f;

double 1.7E-308 a 1.7E308 64 double num2 = 2.125d;

Tabla 2 Tipos de datos reales

Nombre Rango de valores Tamaño en bits Declaración

char 0 a 65536 (Caracteres alfanuméricos) 16 char letra = 'a';

Tabla 3 Tipo de dato caracter

char letra = 70;

'\n' Salto de línea

'\t' Permite un salto al siguiente tope de tabulación

'\b' Retrocede el cursor en un espacio

'\' Se usa para mostrar el carácter '

'\”' Se usa para escribir una comilla doble (“)

'\'' Se usa para escribir una comilla simple (')

'\\' Se usa para mostrar el carácter back-slash (\)

Tabla 4 Secuencias de escape

Nombre Rango de valores Declaración e inicialización

boolean true, false boolean bandera = false;

Tabla 5 Tipo de dato boolean

public final static double PI = 1416; Representan valores inmutables

public final static int CARRO = 1;

Tabla 6 Descripción uso de constantes

1.4 Tipos de datos por referencia

Tabla 8 Clases envoltorio que se usarán en este libro

String direccion= "Carrera 12 #23 10";

A un String se le puede concatenar cualquier tipo de dato primitivo

Actividad 1. Identificar por cada identificador el tipo de dato correspondiente

Una expresión se compone de variables, constantes y/o operadores.

1.5.1 Operadores aritméticos

double res = (( a + b )* 1.0) / 3;

double res = ( a + b ) / 3.0;

1.5.1.1 Operadores de incremento y decremento

x++ Incrementa x después de cualquier operación con ella (post-incremento)

++x Incrementa x antes de cualquier operación con ella (pre-incremento)

x-- Decrementa x después de cualquier operación con ella (post-decremento)

--x Decrementa x antes de cualquier operación con ella (pre-decremento)

Las siguientes expresiones son equivalentes

A continuación, se muestra un ejemplo junto con su equivalencia y resultado final.

Expresión Expresión equivalente Valor final

x = 11; x++; x=11; x = x+1; x = 12;