INFORMÁTICA 1 (Algoritmos con Java)

Universidad Autónoma de Occidente
UNIVERSIDAD AUTÓNOMA DE OCCIDENTE
FACULTAD DE INGENIERÍAS
DEPARTAMENTO DE CIENCIAS DE LA INFORMACIÓN
PROGRAMA DE INGENIERÍA INFORMÁTICA
INFORMÁTICA 1
(Algoritmos con Java)
MATERIAL RECOPILADO POR LOS PROFESORES
J. ANTONIO LEMOS B. Y EDUARDO VICTORIA Z.
SANTIAGO DE CALI, AGOSTO DE 2004
Informática I. Versión 1.0 Agosto de 2004
1
Universidad Autónoma de Occidente
ASIGNATURA:
CODIGO:
CREDITOS:
PRERREQUISITOS:
CARACTERÍSTICAS:
FACULTAD:
PROGRAMA:
DEPARTAMENTO QUE FRECE:
AREA:
PERIODO ACADÉMICO:
INFORMÁTICA 1
532219
3
22 créditos aprobados
HOMOLOGABLE, VALIDABLE
INGENIERÍA
INGENIERÎAS
CIENCIAS DE LA INFORMACIÓN
INFORMÂTICA
Agosto – Diciembre de 2004
OBJETIVO GENERAL
Capacitar al estudiante en el diseño e implementación de algoritmos computacionales, utilizando los
conceptos básicos de la algoritmia, e introduciéndolo en el estudio de la programación orientada a
objetos.
OBJETIVOS ESPECÍFICOS
identificar los sistemas básicos de numeración y sus operaciones
fundamentales.
Comprender las operaciones básicas de la lógica booleana.
Modelar procesos mediante técnicas algorítmicas.
Reconocer y aplicar correctamente las diferentes estructuras de decisión y de
repetición en programación de computadores.
Conocer y apropiar el paradigma Orientado a Objetos y su aplicación en la
programación.
CONTENIDO PROGRAMÁTICO
UNIDAD 1 - Sistemas numéricos
Pág. 7
1.1 Sistema binario
1.2 Sistema octal
1.3 Sistema hexadecimal
1.4 Sistema decimal
1.5 Conversión entre sistemas
1.6 Suma y resta binaria
1.7 Código ASCII y UNICODE
1.8 Clase práctica
UNIDAD 2 - Sistemas lógicos
Pág. 15
2.1 Conectivos relacionales y lógicos
2.2 Proposiciones lógicas simples y compuestas
2.3 Tablas de verdad para las operaciones lógicas básicas
2.4 Clase práctica
UNIDAD 3 - Herramienta de Programación
Informática I. Versión 1.0 Agosto de 2004
Pág. 29
2
Universidad Autónoma de Occidente
3.1 Breve historia de los estilos de Programación
3.2 Origen del paradigma Orientado a Objetos
3.3 Definiciones de clases y objetos
3.4 Características básicas del lenguaje Java
3.5 Construcción básica de una aplicación
3.6 Entrada de datos estándar
3.7 Salida de datos estándar
3.8 Descarga e instalación del lenguaje
3.9 Compilación y ejecución de una aplicación
3.10 Clase práctica
UNIDAD 4 - Tipos de datos, variables y Operadores (Java)
Pág. 61
4.1 Variables
4.2 Palabras reservadas
4.3 Tipos de datos
4.4 Promoción de datos (Casting)
4.5 Operadores aritméticos
4.6 Operador módulo ( % )
4.7 Operadores de asignación
4.8 Operadores de incremento y decremento
4.9 Operadores relacionales
4.10 Operadores lógicos boléanos
4.11 Precedencia y asociatividad de los operadores
4.12 Clase práctica
UNIDAD 5 – Algoritmos
Pág. 69
5.1 Historia de la programación
5.2 Tipos de Algoritmos
5.3 Representación de los Algoritmos
5.4 Propiedades de los Algoritmos
5.5 Clase práctica
UNIDAD 6 - Sentencias de control en Java
Pág. 113
6.1 Sentencias de decisión o selección
6.1.2 Selección simple ( if )
6.1.3 Selección doble ( if – else ; if – else - if )
6.1.4 Selección múltiple ( switch )
6.2 Sentencias de Repetición ( ciclos o bucles):
6.2.1 Ciclo para ( for )
6.2.2 Ciclo mientras ( while )
6.2.3 Ciclo haga mientras ( do – while )
6.3 Clase práctica
UNIDAD 7 – Arreglos
7.1 Definición de Arreglos
7.2 Arreglos Unidimensionales
Informática I. Versión 1.0 Agosto de 2004
3
Universidad Autónoma de Occidente
METODOLOGÍA
El profesor dedicará 180 minutos semanales (dos bloques de 90 minutos) a las actividades
presenciales, las cuales estarán compuestas por:
1) Clases teórico-prácticas en las cuales el profesor expondrá cada uno de los nuevos temas con
ejemplos descriptivos y asignará las lecturas y prácticas necesarias.
2) Talleres (Prácticas Dirigidas) en los cuales, por grupo de estudio, se resolverán ejercicios.
El profesor asesorará a los grupos. Al final todos los estudiantes deberán tener resueltos los
ejercicios y cada grupo avanzará en el proceso de conocimiento según su particular interés
y necesidad de saber. Estos ejercicios realizados en clase deberán ser implementados en
computador en las prácticas de laboratorio.
3) Prácticas Independientes: para ser realizadas en las macro-salas de PC’s de la UAO en el
tiempo libre del estudiante.
4) Se efectuarán 3 evaluaciones parciales de la asignatura con la ponderación que se muestra en
el numeral V. De esta forma, para obtener resultados satisfactorios, el estudiante deberá ir
construyendo el conocimiento a través de aproximaciones sucesivas y durante: las clases,
talleres, trabajo personal y trabajo en grupo de estudio.
EVALUACIÓN
Primer Parcial
Segundo Parcial
Tercer Parcial
Talleres y Quices
Trabajos Adicionales
15%
25%
25%
Mínimo: 3 talleres, 3 quices y 3 trabajos
independientes. Se sugieren grupos de 2
o de 3 estudiantes.
15% (Algunos talleres como trabajo independiente)
20% (Trabajo independiente)
REFERENCIAS BIBLIOGRÁFICAS
1. Área de Informática UAO, Módulo de Informática 1, Publicaciones UAO.
2. CEBALLOS, Francisco J., JAVA 2 Curso de Programación. Ed. Alfaomega. Ra–Ma.
2000.
3. Joyanes Aguilar Luis & Zahonero Martínez Ignacio, “Programación en Java 2 –
Algoritmos, Estructuras de Datos y Programación orientada a Objetos”, Ed. McGrawHill,
2002.
4. DEITEL, H.M., DEITEL, P. J. How to program Java. 3ª Edición. Ed. Prentice Hall. 2000.
5. FROUFE, Augustín. JAVA2 Manual de Usuario y Tutorial. 2ª Edición Ed. Alfa Omega
2000.
6. WU, Thomas C. Introducción a la programación orientada a objetos con Java. Ed. Mc
Graw Hill. España. 2000.
7. ARNOW, David. WEISS, Gerald, Introducción a la programación con Java. Un enfoque
orientado a objetos. Ed. Addison Wesley. España.2001
ELECTRÓNICAS
1.
2.
3.
4.
5.
6.
Descargar el software – J2SE 1.4, del sitio web: http://java.sun.com/downloads
Descargar el editor – JCreator 3.0, del sitio web: http://www.jcreator.com
Documentación de JAVA (JDK 1.4) http://java.sun.com/j2se/1.4/download.html
Tutorial de Java (JDK1.4) http://java.sun.com/docs/books/tutorial/
Free Electronic Books in Java and C++: http://www.ibiblio.org/pub/docs/books/eckel/
FTP: ftp://turing.cuao.edu.co/
Informática I. Versión 1.0 Agosto de 2004
4
Universidad Autónoma de Occidente
FUENTES DE DONDE SE RECOPILÓ EL MATERIAL PARA LA ELABORACIÓN DE
ESTE MÓDULO DE INFORMÁTICA I.
- Universidad de Valencia, España, Depto. de Informática
http://informatica.uv.es/docencia/fguia/TI/Libro/PDFs/CAPI4.pdf
- Universidad de Oviedo,España, Depto. de Informática
Profesor Daniel Gayo.
http://di002.edv.uniovi.es/~dani/asignaturas/
- Aprenda Java como si estuviera en primero, Escuela Superior de Ingenieros Industriales de San
Sebastián.
http://mat21.etsii.upm.es/ayudainf/aprendainf/Java/Java2.pdf
- Matemáticas para Computación, Seymour Lipschutz, McGraw – Hill, 1992
- Informática III, Programación Orientada a Objetos (Java), Recopilación: Lyda Peña Paz
Informática I. Versión 1.0 Agosto de 2004
5
Universidad Autónoma de Occidente
Informática I. Versión 1.0 Agosto de 2004
6
Universidad Autónoma de Occidente
UNIDAD 1. SISTEMAS NUMÉRICOS
ARITMÉTICA Y REPRESENTACIÓN DE LA
INFORMACIÓN EN EL COMPUTADOR
Dos de los aspectos básicos que se presentan en el tratamiento de la información, son cómo
representarla (de lo cual dependerá sus posibilidades de manipulación) y cómo almacenarla
físicamente. La primera se resuelve recurriendo a un código adecuado a las posibilidades internas del
computador, que abordaremos en el presente capítulo. La segunda tiene que ver con los llamados
soportes de información y es una cuestión que pertenece al ámbito del soporte físico del computador.
En la raíz de los desarrollos informáticos está el hecho de que todo dato puede ser representado por
un conjunto de bits (Los dígitos de un número binario se conocen como bits -Binary digit – digito
binario- por su nombre en inglés), circunstancia que permite a la ALU (Unidad Aritmético-Lógica)
realizar un gran número de operaciones básicas utilizando su representación binaria. El paso a
códigos binarios es una misión que el computador lleva a cabo automáticamente, por lo que el
usuario puede despreocuparse de este proceso. Sin embargo es conveniente tener algunas ideas
acerca de la forma como el computador codifica y opera internamente, cuestión indispensable para
comprender determinados comportamientos de la máquina. Para ello empezaremos recordando
algunos conceptos relativos al sistema de numeración binario y a las transformaciones entre éste y el
sistema decimal.
1.1 Sistemas de numeración en informática
Llamaremos sistema de numeración en base b, a la representación de números mediante un
alfabeto compuesto por b símbolos o cifras. Así todo número se expresa por un conjunto de cifras,
contribuyendo cada una de ellas con un valor que depende:
a) de la cifra en sí,
b) de la posición que ocupa dentro del número.
En el sistema de numeración decimal, se utiliza, b = 10 y el alfabeto está constituido por diez
símbolos, denominados también cifras decimales:
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
(1.1)
y, por ejemplo, el número decimal 278.5 puede obtenerse como suma de:
200
70
8
0.5
278 .5
es decir, se verifica que:
278.5 = 2×102 + 7×101 + 8×100 + 5×10-1
Cada posición, por tanto, tiene un peso específico (en el sistema decimal, cada posición además tiene
un nombre):
Valor en el ejemplo
Nombre
posición 0 peso b0
8
unidades
1
posición 1 peso b
7
decenas
posición 2 peso b2
2
centenas
posición -1 peso b-1
5
décimas
Informática I. Versión 1.0 Agosto de 2004
7
Universidad Autónoma de Occidente
Generalizando, se tiene que la representación de un número en una base b:
N = ... n4 n3 n2 n1 n0 . n-1 n-2 n-3 ...
(1.2)
es una forma abreviada de expresar su valor, que es:
N = ... n4b4 + n3b3 + n2b2 + n1b1 + n0b0 + n-1b-1 ... (1.3)
donde el punto separa los exponentes negativos de los positivos.
Nótese que el valor que tome b determina la longitud de la representación; así, por un lado, resulta
más cómodo que los símbolos (cifras) del alfabeto sean los menos posibles, pero, por otra parte,
cuanto menor es la base, mayor es el número de cifras que se necesitan para representar una cantidad
dada. Como ejemplo veamos cual es el número decimal correspondiente de 175372, en base 8, (cuyo
alfabeto es {0, 1, 2, 3, 4, 5, 6, 7} y recibe el nombre de sistema octal).
175372)8 = 1×85 + 7×84 + 5×83 + 3×82 + 7×81 + 2×80 =
= 6×104 + 4×103 + 2×102 + 5×101 + 0×100 = 64250)10
1.1.1 Definición del Sistema Binario
En el sistema de numeración binario b es 2, y se necesita tan sólo un alfabeto de dos elementos para
representar cualquier número: {0,1}. Los elementos de este alfabeto se denominan cifras binarias o
bits. En la Tabla 1.1 se muestran los números enteros binarios que se pueden formar con 3 bits, que
corresponden a los decimales de 0 a 7.
Tabla 1.1.- Números binarios del 0 al 7
binario 000 001 010 011 100 101 110 111
decimal 0
1
2
3
4
5
6
7
Estos números son generados así: el primer dígito de derecha a izquierda se multiplica por 20, el
segundo por 21 y el tercero por 22; por lo tanto el binario 1012 sería
1x22 + 0x21 + 1x20 = 1x4 + 0x2 + 1x1 = 5.
1.1.2 Transformaciones entre bases binaria y decimal
Para transformar un número binario a decimal:
Basta tener en cuenta las expresiones (1.2) y (1.3), en las que b = 2.
Ejemplo 1:
Transformar a decimal los siguientes números binarios:
110100; 0.10100; 10100.001
110100)2 = (1×25) + (1×24) + (1×22) = 25 + 24 + 22 = 32 + 16 +4 = 52)10
0.10100)2 = 2-1 + 2-3 = (1/2) + (1/8) = 0.625)10
10100.001)2 = 24 + 22 + 2-3 = 16+4+(1/8) = 20125)10
Informática I. Versión 1.0 Agosto de 2004
8
Universidad Autónoma de Occidente
Observando el Ejemplo 1 se deduce que se puede transformar de binario a decimal sencillamente
sumando los pesos de las posiciones en las que hay un 1, como se pone de manifiesto en el siguiente
ejemplo.
Ejemplo 2:
Transformar a decimal los números: 1001.001)2 y 1001101)2
1001.001)2 1 0 0 1 0 0 1 = 8 + 1 + 1/8 = 9.125)10
pesos
8 4 2 1 ½ ¼ 1/8
1001101)2 1 0 0 1
pesos
64 32 16 8
1
4
0 1 = 64 + 8 + 4 + 1 = 77)10
2 1
Para transformar un número decimal a binario:
a) La parte entera del nuevo número (binario) se obtiene dividiendo la parte entera del número
decimal por la base, 2, (sin obtener decimales en el cociente) de partida, y de los cocientes que
sucesivamente se vayan obteniendo. Los residuos de estas divisiones y el último cociente (que serán
siempre menores que la base, esto es, 1 o 0), en orden inverso al que han sido obtenidos, son las
cifras binarias.
Ejemplo 3:
Pasar a binario el decimal 26
26
0
2
13 2
1 6
0
26)10 = 11010)2
2
3
1
2
1
1
2
0
b) La parte fraccionaria del número binario se obtiene multiplicando por 2 sucesivamente la
parte fraccionaria del número decimal de partida y las partes fraccionarias que se van obteniendo en
los productos sucesivos. El número binario se forma con las partes enteras (que serán ceros o unos)
de los productos obtenidos, como se hace en el siguiente ejemplo.
Ejemplo 4:
Para pasar a binario el decimal 26.1875 separamos la parte fraccionaria: 0.1875 y la parte entera: 26
(ya transformada en el Ejemplo anterior).
0.1875
×2
0.3750
0.3750
×2
0.7500
0.7500
×2
1.5000
0.5000
x2
1.0000
Por tanto, habiéndonos detenido cuando la parte decimal es nula, el número decimal 26.1875 en
binario es:
26.1875)10 = 11010.0011)2
NOTA: un número real no entero presentará siempre cifras después del punto decimal, pudiendo ser
necesario un número finito o infinito de éstas, dependiendo de la base en que se represente; por
ejemplo el número 1.6)10 representado en binario sería 1.100110011001...)2, requiriendo infinitas
cifras para ser exacto, como también ocurre con muchos números representados en decimal.
Informática I. Versión 1.0 Agosto de 2004
9
Universidad Autónoma de Occidente
1.1.3 Códigos Intemedios
Como acabamos de comprobar, el código binario produce números con muchas cifras, y para evitarlo
utilizamos códigos intermedios que son bases mayores, que no se alejen de la binaria. Estos se
fundamentan en la facilidad de transformar un número en base 2, a otra base que sea una potencia de
2 (22=4; 23=8; 24=16, etc.), y viceversa. Usualmente se utilizan como códigos intermedios los
sistemas de numeración en base 8 (u octal) y en base 16 (o hexadecimal).
1.1.3.1 Base Octal
Un número octal puede pasarse a binario aplicando los algoritmos ya vistos en secciones
anteriores. No obstante, al ser b=8=23, el proceso es más simple puesto que, como puede verse
n525 + n424 + n323 + n222 + n121 + n020 + n-12-1 + n-22-2 + n-32-3 =
(n522 + n421 + n320)× 23 + (n222 + n121 + n020)× 20 + (n-122 + n-221 + n-320)× 2-3 =
(m1)× 81 + (m0)× 80 + (m-1)× 8-1
Cada 3 símbolos binarios (3 bits) se agrupan para formar una cifra de la representación en octal, por
tanto en general puede hacerse la conversión fácilmente, de la forma siguiente:
Para transformar un número binario a octal se forman grupos de tres cifras binarias a partir del
punto decimal hacia la izquierda y hacia la derecha (añadiendo ceros no significativos cuando sea
necesario para completar grupos de 3). Posteriormente se efectúa directamente la conversión a octal
de cada grupo individual de 3 cifras, y basta con recordar como se generaron los números en la tabla
1.1 para poder realizar rápidamente la conversión.
Así por ejemplo
10001101100.1101)2 = 010
2
001
1
101
5
100
4
.
.
110
6
100
4 = 2154.64)8
De octal a binario se pasa sin más que convertir individualmente a binario (tres bits) cada cifra
octal, manteniendo el orden del número original. Por ejemplo:
537.24)8 = 5
3
7
.
2
4
101 011 111 . 010 100 = 101011111.0101)2
Para transformar un número de octal a decimal se aplica la expresión (1.3) con b=8.
Para transformar un número de decimal a octal se procede de forma análoga a como se hizo para
pasar de decimal a binario dividiendo o multiplicando por 8 en lugar de por 2.
Así se puede comprobar que 1367.25)8 = 759.328125)10 ó que 760.33)10 =1370.2507...)8
1.1.3.2 Base Hexadecimal
Para representar un número en base hexadecimal (esto es, b=16) es necesario disponer de un
alfabeto de 16 símbolos:
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F}
Tabla 1.2.- Números binarios del 0 al 7
Hexadec
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Décimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Binario 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
Informática I. Versión 1.0 Agosto de 2004
10
Universidad Autónoma de Occidente
Al ser b=16=24, de modo similar al caso octal, cada símbolo hexadecimal se corresponde con 4
símbolos binarios (4 bits) y las conversiones a binario se realizan agrupando o expandiendo en
grupos de 4 bits. Se pueden comprobar las transformaciones siguientes:
10111011111.1011011)2 = 0101 1101 1111 . 1011 0110
5
D
F . B
6 = 5DF.B6)H
1A7.C4 )H =
1
A
0001 1010
7
.
0111 .
C
1100
4
0100 = 110100111.110001)2
De la misma forma que manualmente es muy fácil convertir números de binario a octal, y viceversa,
y de binario a hexadecimal, y viceversa, también resulta sencillo efectuar esta operación
electrónicamente o por programa, por lo que a veces el computador utiliza este tipo de notaciones
intermedias como código interno o de entrada/salida, y también para visualizar el contenido de la
memoria o de los registros.
Para transformar un número de hexadecimal a decimal se aplica la expresión (1.3) con b=16.
Para pasar un número de decimal a hexadecimal se hace de forma análoga a los casos binario y
octal: la parte entera se divide por 16, así como los cocientes enteros sucesivos, y la parte
fraccionaria se multiplica por 16, así como las partes fraccionarias de los productos sucesivos.
Así se puede comprobar que 12A5.7C)H = 4773.484375)10 ó que 16237.25)10 = 3F6D.4)H
1.2 Operaciones Aritméticas y Lógicas
El procesamiento de la información incluye realizar una serie de operaciones con los datos;
estas operaciones y las particularidades de las mismas en su realización por el computador son el
objeto de los próximos apartados.
Operaciones Aritméticas con Números Binarios
Las operaciones aritméticas básicas (suma, resta, multiplicación y división) en sistema binario se
realizan en forma análoga a la decimal aunque, por la sencillez de su sistema de representación, las
tablas son realmente simples:
Tabla 1.3.- Operaciones básicas en binario
Suma aritmética
Resta aritmética
Producto aritmético
0+0=0
0-0=0
0.0=0
0+1=1
0 - 1 = 1 y debo 1 (*)
0.1=0
1+0=1
1-0=1
1.0=0
1 + 1 = 0 y llevo 1(*)
1-1=0
1.1=1
(*) Llamado normalmente acarreo. En binario 1+1=10 (es 0 y me llevo 1), igual que en decimal
6+6=12 (es 2 y me llevo 1)
Resta en un SC2
Se toma el sustraendo y se le hace complemento a uno (negación de cada bit). Posteriormente a
este número se le suma uno, dando como resultado el complemento a dos. Este último resultado (que
equivale al sustraendo negativo) se le suma al minuendo y obtendremos la respuesta. Si el número de
términos excede al minuendo, se debe realizar desbordamiento de extremos. (No se toma el bit de
extrema izquierda en el resultado ).
Informática I. Versión 1.0 Agosto de 2004
11
Universidad Autónoma de Occidente
Ejemplo 5:
(minuendo) 0 1 1 1 (7)
(sustraendo) -0 1 0 1 (5)
Complemento a uno del sustraendo
1 0 1 0
Se suma uno
+
1
Complemento a dos
1 0 1 1 (-5)
Minuendo
Complemento a dos
0 1 1 1 (7)
+ 1 0 1 1 (-5)
Como se presenta acarreo se omite el bit
de extrema izquierda.
Respuesta
Ejemplo 6:
0 0 1 0 (2)
Minuendo
Sustraendo
0 1 0 0 1 0 1 1 ( 75)
0 1 1 0 1 0 0 1 (105)
Complemento a uno del sustraendo
Se suma uno
+
Complemento a dos
Complemento a dos
Suma minuendo
Respuesta
+
1 0 0 1 0 1 1 0
_______
1
1 0 0 1 0 1 1 1 (-105)
0 1 0 0 1 0 1 1 ( 75)
1 0 0 1 0 1 1 1 (-105)
1 1 1 0 0 0 1 0 (- 30)
Ejemplo 7:
Efectuar las siguientes operaciones aritméticas binarias:
1110101
+1110110
11101011
1101010
-1010111
0010011
1101010
×11
1101010
1101010_
100111110
1010011
×10
0000000
1010011_
10100110
110.01 10
10
11.001
010
10
00010
10
00
A partir del ejemplo anterior, se observa que multiplicar por 10)2 (es decir, por 2 en decimal)
equivale a añadir un cero a la derecha, o desplazar el punto decimal a la derecha, siendo esto similar
a multiplicar por 10)10 un número decimal. De la misma forma dividir por 10)2 = 2)10 equivale a
eliminar un cero a la derecha, o desplazar el punto decimal a la izquierda.
Por ejemplo:
1010011)2 × 2 = 10100110)2
10101.01)2 × 2 = 101010.1)2
1.101101)2 × 25 = 110110.1)2
Informática I. Versión 1.0 Agosto de 2004
1010100)2 / 2 = 101010)2
110.01)2 / 2 = 11.001)2
10101.101)2 / 26 = 0.010101101)2
12
Universidad Autónoma de Occidente
Ejercicios
Llene todas las casillas en blanco, sabiendo que las columnas agrupan el sistema numérico y el
número a convertir lo da la fila que tenga el dato.
DECIMAL
BINARIO
OCTAL
HEXA
230
1101001
326
BC3
A48D
1543
100100101
1872
255
Realice las siguientes operaciones :
Operando 1
Operando 2
11000011
10000
1001110010
11100101
1101
1100111
1101001111
101101111
1111111111111
1111
1010101011
10100001
11111100000
1010101010
101000001100
11000110010
11001010000010
10001111100011
11001010
1011111
101100110101
1110000001
10101110110
10101
11111111111
1111111111
100100000010
1011111
1001111101111110000 1111111000000000000
Suma
Resta
1.2.2 Valores Booleanos y Operaciones Lógicas
Un dígito binario, además de representar una cifra en base dos, también puede interpretarse como un
valor booleano o dato lógico (en honor a George Boole), entendiendo como tal una cantidad que
solamente puede tener dos estados (Verdadero/Falso, SI/NO, 1/0, etc.) y por tanto con capacidad
para modelizar el comportamiento de un conmutador. Así, además de las operaciones aritméticas con
valores binarios, se pueden llevar a cabo operaciones booleanas o lógicas en las que estos valores se
consideran señales generadas por conmutadores. Las operaciones booleanas más importantes son:
OR lógico (también denominado unión, suma lógica (+) o función O),
AND lógico (también intersección, producto lógico ( . ) o función Y)
la complementación ( - ) (o inversión, negación, o función NOT o NO).
Nótese que las dos primeras son operaciones de dos operandos o binarios mientras que la
complementación es unaria. Estas operaciones se rigen según la Tabla 4.4.
Informática I. Versión 1.0 Agosto de 2004
13
Universidad Autónoma de Occidente
Tabla 1.4.- Operaciones lógicas
OR
0+0=0
0+1=1
1+0=1
1+1=1
__
AND ______
0.0=0
0.1=0
1.0=0
1.1=1
NOT
0=1
1=0
Como puede observarse, el AND y OR lógicos se corresponden parcialmente con el producto y suma
binarios, y lo más significativo, es la posibilidad de implementar estas operaciones lógicas, y por
tanto las aritméticas binarias, en forma de circuitos. En la siguiente unidad se revisa más
ampliamente las operaciones lógicas.
Informática I. Versión 1.0 Agosto de 2004
14
Universidad Autónoma de Occidente
UNIDAD 2. SISTEMAS LÓGICOS
LOGICA, TABLAS DE VERDAD
2.1 Introducción.
Un computador puede ser programado para tomar decisiones basadas en si ciertos enunciados –por
ejemplo, “El numero que se ha computado es mayor que 100”-son verdaderos o falsos. A la verdad o
falsedad de un enunciado se le llama valor de verdad; un enunciado es verdadero o falso, pero no
ambas cosas. Algunos enunciados son enunciados compuestos, es decir, están integrados por
subenunciados y varias conectivas.
Ejemplo 1:
(a) “Las rosas son rojas y las violetas azules” es un enunciado compuesto por los subenunciados
“las rosas son rojas” y “las violetas son azules”.
(b) “El es inteligente o estudia todas las noches” es, implícitamente, un enunciado compuesto por
los subenunciados “El es inteligente” y “estudia todas las noches”.
(c) “¿Para donde va?” no es un enunciado ya que no es ni verdadero ni falso.
La propiedad fundamental de un enunciado compuesto es que su valor de verdad esta
completamente determinado por los valores de verdad de sus subenunciados junto con la
manera como estan conectados para formar el enunciado compuesto. Comenzamos con un
estudio de algunas de estas conectivas. En este capitulo usaremos las letras p, q, r (en
minúsculas o mayúsculas, con o sin subíndices) para denotar enunciados.
2.2 Conjunción, p ^ q
Dos enunciados cualesquiera se pueden combinar con la palabra “y” para formar un enunciado
compuesto llamado la conjunción de los enunciados originales. Simbólicamente, p ^ q.
Denota la conjunción de los enunciados p y q, que se lee “p ^ q”.
La tabla de verdad del enunciado compuesto p ^ q esta dada por la siguiente tabla:
p
q
p^q
V
V
V
V
F
F
F
V
F
F
F
F
En este caso, la primera línea es una manera abreviada de decir que si p es verdadero y q es
verdadero, entonces p ^ q es verdadero. Las otras líneas tienen significados análogos. Consideramos
que esta tabla define precisamente el valor de verdad del enunciado compuesto p ^ q como una
función de los valores de verdad de p y de q. Observe que p ^ q es verdadero solamente en el caso en
que ambos subenunciados sean verdaderos.
Informática I. Versión 1.0 Agosto de 2004
15
Universidad Autónoma de Occidente
Ejemplo 2: Considere los cuatro enunciados siguientes:
(i) Paris esta en Francia y
(ii) Paris esta en Francia y
2+2=4.
(iii) Paris esta en Inglaterra y 2+2=4.
2+2=5 (iv) Paris esta en Inglaterra y 2+2=5.
Solamente el primer enunciado es verdadero. Cada uno de los otros enunciados es falso ya que por lo
menos uno de sus subenunciados es falso.
2.3 Disyunción, p ν q
Dos enunciados pueden combinarse con la palabra “o” (en el sentido de “y/o”) para formar un nuevo
enunciado que se llama la disyunción de los dos enunciados originales. Simbólicamente, p ν q.
Denota la disyunción de los enunciados p y q y se lee “p o q”.
El valor de verdad de p ν q esta dado por la siguiente tabla de verdad, que consideramos define a
p ν q:
p
q
pνq
V
V
F
F
V
F
V
F
V
V
V
F
Observe que p ^ q es falso solamente cuando ambos enunciados son falsos.
Ejemplo 3: Considere los cuatro enunciados:
(i) Paris esta en Francia o
(ii) Paris esta en Francia o
(iii) Paris esta en Inglaterra o
(iv) Paris esta en Inglaterra o
2 + 2 = 4.
2 + 2 = 5.
2 + 2 = 4.
2 + 2 = 5.
Solamente (iv) es falso. Cada uno de los otros enunciados es verdadero ya que por lo menos uno de
sus subenunciados es verdadero.
Observación: La palabra española “o” se usa comúnmente de dos maneras. Algunas veces se usa
en el sentido de “p o q o ambos”, mejor dicho, por lo menos una de las dos alternativas ocurre, como
antes se señaló y algunas veces se usa en el sentido de “ p o q pero no ambos”, mejor dicho,
exactamente una de las dos alternativas ocurre. Por ejemplo, la frase “ El estudiara en la Universidad
Nacional o en la Universidad Católica” usa el “o” en el segundo sentido llamado disyunción exclusiva.
A no ser que se diga otra cosa, la “o” se usara en el primer sentido. Esta observación hace sobresalir
la precisión que ganamos con nuestro lenguaje simbólico: pν q esta definido por su tabla de verdad y
siempre significa “p y / o q”.
2.4 Negación, ~ p
Dado cualquier enunciado p, se puede formar otro enunciado, llamado la negación de p, escribiendo “
Es falso que...” antes de p o, si es posible insertando en p la palabra “no”. Simbólicamente, ~ p,
denota la negación de p (se lee “no p”).
Informática I. Versión 1.0 Agosto de 2004
16
Universidad Autónoma de Occidente
La tabla de verdad de ~ p esta dada por la siguiente tabla:
p
~p
F
V
V
F
En otras palabras, si p es verdadero entonces ~ p es falso entonces ~ p es verdadero. Así, el valor de
verdad de la negación de cualquier enunciado es siempre el opuesto del valor de verdad del enunciado
original.
Ejemplo 4: Considere los siguientes enunciados
(a) Paris esta en Francia.
(b) Es falso que Paris esta en Francia.
(c) Paris no esta en Francia.
(d) 2 + 2= 5
(e) Es falso que 2 + 2=5.
(f ) 2 + 2 ≠ 5.
Entonces (b) y (c) son cada una de la negación de (a); y (e) y (f) son cada uno la negación de (d. Ya
que (a) es verdadero, los enunciados (b) y (c) son falsos; y como (d) es falso, los enunciados (e) y (f)
son verdaderos.
Observación: La notación lógica para las conectivas “y”, “o” y “no” no es estándar. Por ejemplo,
algunos textos usan:
p & q. p . q o pq para p ^ q
p+q
para pν q
p’ . p o ┐p
para ~ p
2.5 Proposiciones y Tablas de Verdad
Con su uso repetido de las conectivas lógicas (^, ν, ~ y otras que se discutirán adelante), podemos
construir enunciados compuestos que son mas elaborados. En el caso en que los subenunciados p, q,
... de un enunciado compuesto P (p,q,...) sean variables, llamamos al enunciado compuesto una
proposición.
Ahora el valor de verdad de una proposición depende exclusivamente de los valores de verdad de
sus variables, mejor dicho, el valor de verdad de una proposición se conoce una vez que se conozcan
los valores de verdad de sus variables. La tabla de verdad de la proposición ~ (p ^ ~ q), por ejemplo,
se construye como sigue:
p
q
V
V
F
F
V
F
V
F
~q
F
V
F
V
p^~q ~(p^~q)
F
V
F
F
V
F
V
V
Observe que las primeras
columnas de la tabla son para
las variables p,q,...y que hay suficientes líneas en la tabla para permitir todas las posibles
combinaciones de V y F para estas variables. (Para 2 variables, como en el caso anterior, se necesitan
4 líneas; para 3 variables se necesitan 8 líneas; y, en general, para n variables se necesitan 2n líneas.)
Hay pues una columna para cada etapa “elemental” de la construcción del enunciado el valor de
verdad de cada paso es determinado por las etapas anteriores con las definiciones de las conectivas ^,
ν, ~. Finalmente, obtenemos la tabla de verdad de la proposición, que aparece en la ultima columna.
Informática I. Versión 1.0 Agosto de 2004
17
Universidad Autónoma de Occidente
Observación: La tabla de verdad de la proposición, anterior consiste precisamente en las
columnas bajo las variables y la columna bajo la proposición:
p
q
V
V
F
F
V
F
V
F
~(p^~q)
V
F
V
V
Las otras columnas se usaron solamente en la construcción de la tabla de verdad.
Otra manera de construir la tabla de verdad anterior para ~ (p ^ ~ q) es la siguiente. Primero se
construye la siguiente tabla:
p
V
V
F
F
~
q
V
F
V
F
(p
^
~
q)
Paso
Observe que la proposición se escribe en la línea superior a la derecha de sus variables, y que hay una
columna bajo cada variable o conectiva de la proposición. Los valores de verdad se colocan entonces
en la tabla de verdad en varios pasos como sigue:
P
q
~
V
V
V
F
F
V
F
F
Paso
(p
^
~
V
V
F
F
1
q)
V
F
V
F
1
p
q
V
V
F
F
V
F
V
F
q
V
V
V
F
F
V
F
F
Paso
(c )
~
(p
Paso
(a)
P
~
~
q)
V
V
F
F
^
F
V
F
V
V
F
V
F
1
2
1
(b)
(p
^
~
q)
V
V
F
F
1
F
V
F
F
3
F
V
F
V
2
V
F
V
F
1
p
V
F
F
F
q
V
V
F
F
Paso
(d)
~
(p
^
~
q)
V
F
V
V
4
V
V
F
F
1
F
V
F
F
3
F
V
F
V
2
V
F
V
F
1
La tabla de verdad de la proposición está formada, pues, por las columnas originales bajo las variables
y la última columna colocada en la tabla, mejor dicho, el último paso.
2.6 Tautologías y Contradicciones
Algunas proposiciones P(p, q,…) contienen solamente V en la última columna de sus tablas de verdad,
es decir, son verdaderas para cualquier valor de verdad de sus variables. A tales proposiciones se les
Informática I. Versión 1.0 Agosto de 2004
18
Universidad Autónoma de Occidente
llama tautologías. Análogamente, una proposición P(p,q,…)se llama contradicción si contiene
solamente F en la última columna de su tabla de verdad, o sea, es falso para cualquier valor de verdad
de sus variables. Por ejemplo, la proposición “p o no p”, es decir, p ν ~ p, es una tautología y la
proposición “p y no p”, es decir, p ^ ~ p, es una contradicción. Esto se verifica construyendo sus
tablas de verdad.
p
V
F
p
~p pν~p
F
V
V
F
V
V
~ p p ^~ p
F
V
F
F
Observemos que la negación de una tautología es una contradicción ya que siempre es falsa, y la
negación de una contradicción es una tautología ya que siempre es verdadera.
Ahora, sea P(p, q, ...) una tautología, y sean P (p, q, ...), P (p,q,...),...proposiciones
cualesquiera. Como el valor de verdad de P(p,q,...) no depende de los valores de verdad particulares
de sus variables p, q, ... podemos reemplazar P , q por P , ...en la tautología P(p, q, …) y tenemos
aún una tautología. En otras palabras:
Principio de substitución: Si P (p, q, ...) es una tautología, entonces P(P1, P2,...) es una
tautología para proposiciones cualesquiera P1, P2,...
Ejemplo 5: Por la anterior tabla de verdad, pν ~ p es una tautología. Reemplazando p por q ^ r
obtenemos la proposición ( q ^ r ) ν ~ ( q ^ r ) que, por el principio de substitución también debiera
ser una tautología.
Esto se verifica con la siguiente tabla de verdad.
.
q
r
q^r
V
V
F
F
V
F
V
F
V
F
F
F
~ (q^r)
(q^r)ν ~(q^r)
F
V
V
V
V
V
V
V
2.7 Equivalencia Lógica: Álgebra de Proposiciones
Se dice que dos proposiciones P ( p, q, ...) y Q (p, q, ...) son lógicamente equivalentes, o sencillamente
equivalentes o iguales, denotado por
P (p, q, ...) ≡ Q (p, q, …)
Si tienen identicas tablas de verdad. Por ejemplo, considere las tablas de verdad de ~ ( p^q) y ~ pν q:
p
q
p^q ~ (p^q)
V
V
F
F
V
F
V
F
V
F
F
F
F
V
V
V
p
Q
~p
~q
V
V
F
F
V
F
V
F
F
F
V
V
F
V
F
V
~pν~q
F
V
V
V
Como las tables de verdad son las mismas, mejor dicho, ambas proposiciones son falsas en el primer
caso y verdaderas en los otros tres casos, las proposiciones ~ ( p ^ q) y ~ p ν ~ q son lógicamente
equivalentes y podemos escribir:
~ ( p^q) ≡ ~ p ν ~ q
Informática I. Versión 1.0 Agosto de 2004
19
Universidad Autónoma de Occidente
Ejemplo 6: Considere el enunciado
“ Es falso que las rosas son rojas y las violetas son azules”.
Este enunciado se puede escribir en la forma ~ ( p ^ q) en donde p es “ las rosas son rojas” y q es “las
violetas son azules”. Sin embargo, por las tablas de verdad anteriores, ~ ( pν q) es lógicamente
equivalente con ~ p ν ~ q.
Asi, el enunciado dado tiene el mismo significado que el ennunciado.
“Las rosas no son rojas, o las violetas no son azules”.
Las proposiciones satisfacen muchas equivalencias logicas, o leyes, fuera de las descritas
anteriormente. Algunas de las leyes mas importantes, con sus nombres se dan en la tabla 2.1. en la
tabla, t denota una tautología y f denota una contradicción.
2.8 Enunciados Condicional y Bicondicional
Muchos enunciados, particularmente en la matemática, son de la forma “Si p entonces q”. Tales
enunciados se llaman enunciados condicionales y se denotan por p → q
El condicional p → q frecuentemente se lee “ p implica q” o “p sólo si q”.
Otro enunciado común es la forma “p si y solo si q”. Tales enunciados denotados por p ↔ q se
llaman enunciados bicondicionales.
Los valores de verdad de p→ q y p ↔ q se dan en las siguientes tablas:
p
V
V
F
F
q
V
F
V
F
p→ q
V
F
V
V
p
V
V
F
F
q
V
F
V
F
p↔q
V
F
F
V
Leyes de idempotencia
pν p ≡ p
1b. p ^ p ≡ p
1a.
Leyes Asociativas
2a
(pν q) ν r≡ pν (qν r)
2b. (p ^ q) ^ r ≡ p ^ ( q ^ r)
Leyes conmutativas
pν q≡ qν p
3b. p ^ q ≡ q ^ p
3a
Leyes distributivas
pν ( q ^ r) ≡ (pν q) ^ (pν r)
4b. p ^ (q ν r) ≡
4a
(p ^ q) ν (p ^ r)
Leyes de identidad
5a
pν f ≡ p
5b. p ^ t ≡ p
6a
pν t≡ t
6b. p ^ f ≡ f
Leyes de complementos
pν ~ p ≡ t
7b. p ^ ~ p ≡ f
7a
8a ~ t ≡ f
8b. ~ f ≡ t
9
~ ~ p≡p
Ley de involución
Leyes de DeMorgan
10a. ~ (p ν q) ≡ ~ p ^ ~ q 10b. ~ (p ^ q) ≡ ~ p ν ~ q
Tabla 2.1. Leyes del Álgebra de Proposiciones
Informática I. Versión 1.0 Agosto de 2004
20
Universidad Autónoma de Occidente
Observe que el condicional p→ q es falso solamente cuando la primera parte p es verdadera y la
segunda parte q es falsa. En caso de que p sea falso, el condicional p→ q es verdadero sin importar
el valor de verdad de q. Observe tambien que p ↔ q es verdadero cuando p y q tienen los mismos
valores de verdad y falso en los demas casos.
Ahora considere la tabla de verdad de la proposicion ~ pν q:
p
V
V
F
F
q
V
F
V
F
~p
F
F
V
V
~pνq
V
F
V
V
Observe que la anterior tabla de verdad es idéntica a la tabla de verdad de p → q. Así que p→ q es
lógicamente equivalente a la proposición ~ p ν q:
p→q≡~pνq
En otras palabras, el enunciado condicional “Si p entonces q” es lógicamente equivalente al enunciado
“No p o q”, que solamente usa las conectivas ν y ~ y, por lo tanto, ya era parte de nuestro lenguaje.
Considere la proposicion condicional p → q y las otras proposiciones condicionales simples que
contienen p y q:
q → p, ~ p → ~ q y ~ q → ~ p
Estas proposiciones se llaman respectivamente la reciproca, inversa, y contrarreciproca de la
proposicion p → q. En seguida presentamos las tablas de verdad de las cuatro proposiciones.
Condicional
p
V
V
F
F
q
V
F
V
F
p→q
V
F
V
V
Recíproca
q→ p
V
V
F
V
Inversa
~p→~q
V
V
F
V
Contrarecíproca
~q→ ~p
V
F
V
V
Observe que un enunciado condicional y su reciproco o inverso no son lógicamente equivalentes. Por
otra parte, se puede ver que un enunciado condicional y su contrarreciproco son lógicamente
equivalentes. Enunciamos este resultado formalmente:
Teorema 2.1: Un enunciado condicional p→ q y su contrarreciproca ~ q→ ~ p son lógicamente
equivalentes.
Ejemplo 7:
(a) Considere los siguientes enunciados sobre un triangulo A:
p→ q: Si A es equilatero, entonces A es isoseles.
q→ p: Si A es Isoseles, entonces A es equilatero.
En este caso p→ q es verdadero, pero su reciproco q→ p es falso.
(b) Sea x un entero. Demuestre: (p→ q). Si x² es impar entonces x es impar.
Demostramos que la contrarreciproca ~ q→ ~ p, “Si x es par, entonces x² es par” es
verdadera. Sea x par; entonces, x = 2n en donde n es un entero. Por lo tanto,
x² = (2n)(2n) = 2(2n² )
Informática I. Versión 1.0 Agosto de 2004
21
Universidad Autónoma de Occidente
tambien es par. Como la contrarreciproca ~ q→ ~ p es verdadera, el enunciado condicional
original p→ q es tambien verdadero.
2.9 Argumentos
Un argumento es una relacion entre un conjunto de proposiciones P1,P2,..., Pn, llamadas
premisas, y otra proposicion Q, llamada la conclusión; denotamos un argumento por
P1,P2,..., Pn + Q
Se dice que un argumento es valido si las premisas dan (como consecuencia) la conclusión; mas
formalmente, damos la siguiente
Definición: Un argumento P1,P2,,...., Pn + Q es válido si Q es verdadero cada vez que las
premisas P1,P2,..., Pn sean verdaderas.
Un argumento que no es válido se llama falacia.
Ejemplo 8:
(a) El siguiente argumento es válido:
p.p → q + q (Ley de independencia, modus poniendo ponens.)
la demostración de esta regla se sigue de la siguiente tabla de verdad.
p
q
p→q
V V
V
V F
F
F V
V
F F
V
Ya que p es verdadero en los casos (lineas) 1 y 2, y p → q es verdadero en los casos 1, 3 y 4; se sigue
que p y q → q son verdaderos simultáneamente en el caso 1. como en este caso q es verdadero, el
argumento es valido.
(b) El siguiente argumento es una falacia: p → q, q + p. Ya que p → q y q son ambos verdaderos en
el caso (linea) 3 en la anterior tabla de verdad, pero en este caso p es falso.
Ahora las proposiciones P1,P2,..., Pn son verdaderas simultáneamente si y solo si la proposicion
(P1 ^ P2 ^...^ Pn) es verdadera. Asi el argumento P1,P2,..., Pn + Q es valido si y solo si Q es verdadero
cada vez que P1 ^ P2 ^...^ Pn sea verdadero o, equivalentemente, si y solo si la proposicion
(P1 ^ P2 ^...^ Pn) → Q
Es una tautologia. Establecemos este resultado formalmente.
Teorema 2.2: El argumento P1,P2,..., Pn + Q es valido si y solo si (P1 ^ P2 ^...^ Pn) → Q es una
tautologia.
En el siguiente ejemplo aplicamos este teorema.
Ejemplo 9: Un principio fundamental del racionamiento logico dice:
“Si p implica q y q implica r, entonces p implica r”
O sea, el siguiente argumento es valido:
Informática I. Versión 1.0 Agosto de 2004
22
Universidad Autónoma de Occidente
p→ q. q → r + p→ r (ley del silogismo)
Este hecho se verifica con la siguiente tabla de verdad que muestra que la proposicion
[(p→ q) ^ (q → r)] → (p→ r)
Es una tautologia:
q
r [(p →
q)
^
(q
→
r)] →
(p
→
r)
V
V
V
V
V
V
V
V
V
V
V
V
V
V
F
V
V
V
F
V
F
F
V
V
F
F
F
V
V
F
F
F
F
V
V
V
V
V
V
F
F
V
F
F
F
F
V
F
V
V
F
F
V
V
F
V
V
V
V
V
V
V
F
V
V
V
F
F
V
V
F
V
F
F
V
F
V
F
F
V
F
V
F
V
F
V
V
V
F
V
V
F
F
F
V
F
V
F
V
F
V
F
V
F
Paso
1 2
1
3
1
2
1
4
1
2
1
Equivalentemente, el argumento es valido ya que las premisas p→ q y q→ r son verdaderas
simultáneamente solo en los casos (lineas) 1, 5, 7 y 8, y en estos casos la conclusión p→ r tambien es
verdadera. (observe que la tabla de verdad requiere 2³ = 8 lineas, ya que hay tres variables p, q y r.)
p
V
V
V
V
F
F
F
F
Es necesario destacar que la validez del argumento no depende de los valores de verdad o del
contenido de los enunciados que aparecen en el argumento, sino solamente de la estructura formal del
argumento. Esto se ilustra con el siguiente ejemplo.
Ejemplo 10: Considere el siguiente argumento:
S1: Si un hombre es soltero, es infeliz.
S2: Si un hombre es infeliz, muere joven.
.................................................................
S: Los solteros mueren jóvenes.
En este caso el enunciado S debajo de la línea denota la conclusión del argumento, y los enunciados
S1 y S2 por encima de la línea denotan las premisas. Afirmamos que el argumento es de la forma
p→ q , q→ r + p → r
Es donde p es “El es soltero”, q es “El es infeliz” y r es “El muere joven”; y por el ejemplo 4.9 este
argumento (Ley de silogismo) es válido.
2.10 Implicación Lógica.
Se dice que una proposición P (p,q,...) implica lógicamente una proposición Q (p,q,...), escrito
P (p,q,...)⇒ Q (p, q, ...)
Si Q (p, q, ...) es verdadera cada vez que P (p,q,...) sea verdadera.
Ejemplo 11: Afirmamos que P implica lógicamente p ν q. Considere las tablas de verdad de p y de
p ν q en la tabla de abajo. Observe que p es verdadera en los casos (líneas) 1 y 2, y en estos casos
pν q también es verdadera. En otras palabras , p implica lógicamente p ν q.
Informática I. Versión 1.0 Agosto de 2004
23
Universidad Autónoma de Occidente
p q pν q
V V
V F
F V
F F
V
V
V
F
Ahora si Q (p, q, ...) es verdadera cada vez que P (p,q,...) sea verdadera, entonces el argumento
P (p,q,...) + Q (p, q, ...)
es válido, y recíprocamente. Aún más, el argumento P + Q es válido si y solo si el enunciado
condicional P → Q es siempre verdadero, o sea, si es una tautología. Establecemos este resultado
formalmente.
Teorema 3: Para proposiciones cualesquiera P (p,q,...) y Q (p, q, ...) los tres enunciados siguientes
son equivalentes:
(i)
(ii)
(iii)
P (p,q,...) implica lógicamente a Q (p, q, ...).
El argumento P (p,q,...) + Q (p, q, ...) es válido.
La proposición P (p,q,...) → Q (p, q, ...) es una tautología.
Si P ⇒ Q y Q ⇒ P entonces P y Q deben tener la misma tabla de verdad, y por lo tanto P ≡ Q. El
reciproco también es cierto. Así, la noción de implicación lógica está intimamente ligada a la de la
equivalencia lógica.
PROBLEMAS RESUELTOS
Enunciados y Enunciados Compuestos.
2.1 Sea p “Hace frió” y sea q “Está lloviendo”. Dé una frase verbal sencilla que describa cada uno de
los siguientes enunciados:
(1) ~ p,
(2) p ^ q,
(3) p ν q,
(4) qν ~p,
(5) ~p ^ ~q,
(6) ~ ~ q
En cada caso, traduzca ^, ν y ~ para que se lea “y”, “o” y “Es falso que” o “No”,
respectivamente, y luego simplifique la frase en español.
(1) No hace frió.
(4) Está lloviendo o no está haciendo frío.
(2) Está haciendo frío y está lloviendo. (5) Ni está haciendo frío ni está lloviendo.
(3) Está haciendo frío o está lloviendo (6) No es verdad que esté lloviendo.
2.2 Sea p “El es alto” y sea q “El es buen mozo”. Escriba cada uno de los siguientes enunciados en
forma simbólica usando p y q. (Suponga que “El es bajo” significa “El no es alto”, o sea ~ p.).
(1) El es alto y buen mozo.
(2) El es alto pero no buen mozo.
(3) Es falso que el sea bajo o buen mozo.
(1) p ^ q
(2) p ^ ~q
Informática I. Versión 1.0 Agosto de 2004
(4) El no es ni alto ni buen mozo.
(5) El es alto, o es bajo y buen mozo.
(6) No es cierto que él sea bajo o no buen mozo.
(3) ~ (~p ν q)
(4) ~p ^ ~q
(5) p ν (~p ^ q)
(6) ~ (~ p ν ~q)
24
Universidad Autónoma de Occidente
Proposiciones y sus Tablas de Verdad.
2.3 Encuentre la tabla de verdad de ~ p ^ q.
p
V
V
F
F
q
V
F
V
F
p
V
V
F
F
Paso
2
Método 2
Método 1
~
F
F
V
V
q
~p
V
F
F
F
V
V
F
V
1
3
p
^
V
F
V
F
F
V
F
F
~p^q
F
F
V
F
1
q
V
F
V
F
2.4 Encuentre la tabla de verdad de ~ (p ν q).
p
V
V
F
F
q
V
F
V
F
p
V
V
F
F
p ν q ~ (p ν q)
V
F
V
F
V
F
F
V
q
V
F
V
F
Paso
Método 1
~
F
F
F
V
(p
V
V
F
F
ν
q)
V
F
V
F
V
V
V
F
3 1
2
Método 2
1
2.5 Encuentre la tabla de verdad de ~ (p ν ~ q).
p q
V V
V F
F V
F F
~ q p ν ~ q ~ (p ν ~ q)
F
V
F
V
V
F
F
F
V
V
V
F
Método1
p
q
V V
V F
F V
F F
Paso
Método 2
~ (p ν ~ q)
F V V
F V V
V F F
F F V
4 1 3
F
V
F
V
2
V
F
V
F
1
(observe que esta tabla de verdad es idéntica a la del problema 2.3)
Tautologías y Contradicciones.
2.6 Verifique que la proposición p ν ~ (p ^ q) es una tautología.
Construya la tabla de verdad de p ν ~ (p ^ q):
p
V
V
F
F
Informática I. Versión 1.0 Agosto de 2004
q
V
F
V
F
p^ q
V
F
F
F
~ (p ^ q)
F
V
V
V
p ν ~ (p ^ q)
V
V
V
V
25
Universidad Autónoma de Occidente
Como la tabla de verdad de p ν ~ (p ^ q) es verdadera para todos los valores de verdad de p y de
q, entonces es una tautología.
2.7 Verifique que la proposición (p ^ q) ^ ~ (p ν q) es una contradicción.
Construya la tabla de verdad de (p ^ q) ^ ~ (p ν q):
P q
V V
V F
F V
F F
p ^ q p ν q ~ (p ν q)
V
V
F
F
V
F
F
V
F
F
F
V
(p ^ q) ^ ~ (p ν q)
F
F
F
F
Como la tabla de verdad de (p ^ q) ^ ~ (p ν q) es F para todos los valores de verdad de p y de q,
entonces es una contradicción.
Equivalencia Lógica.
2.8 Demuestre que la disyunción distribuye sobre la conjunción, o sea, demuestre la ley distributiva
p ν (q ^ r) ≡ ( p ν q) ^ (p ν r).
Construya las tablas de verdad requeridas.
p
V
V
V
V
F
F
F
F
q
V
V
F
F
V
V
F
F
r q^r
V
V
F
F
V
F
F
F
V
V
F
F
V
F
F
F
p ν (q ^ r)
V
V
V
V
V
F
F
F
pνq pν r
V
V
V
V
V
V
V
V
V
V
V
F
F
V
F
F
( p ν q) ^ (p ν r)
V
V
V
V
V
F
F
F
Como las tablas de verdad son idénticas, las proposiciones son equivalentes.
2.9 Demuestre que la operación de disyunción se puede escribir en términos de las operaciones
conjunción y negación. Específicamente, p ν q≡ ~ (~ p ^ ~ q).
Construya las tablas de verdad requeridas
p
V
V
F
F
q pνq ~p ~q ~p^~q
V
V
F
F
F
F
V
F
V
F
V
V
V
F
F
F
F
V
V
V
~ (~ p ^ ~ q)
V
V
V
F
Como las tablas de verdad son idénticas, las proposiciones son equivalentes.
Informática I. Versión 1.0 Agosto de 2004
26
Universidad Autónoma de Occidente
2.10 Simplifique cada proporción usando la tabla 2-1: (a) p ν (p ^ q), (b) ~( pν q) ν (~ p ^ q).
(a)
Equivalencia
(1) p ν (p ^ q) ≡ (p ^ t) ν (p ^ q)
(2)
≡ p ^ ( t ν q)
(3)
≡p^t
≡p
(4)
(1)
(2)
(3)
(4)
Razón
Ley de Identidad
Ley distributiva
Ley de Identidad
Ley de Identidad
(b)
Equivalencia
(1) ~ (p ν q)ν (~ p ^ q) ≡ (~ p ^ ~ q) ν (~ p ^ q)
(2)
≡ ~ p ^ (~ p ν q)
(3)
≡ ~p^t
(4)
≡ ~p
Razón
(1) Ley de DeMorgan
(2) Ley distributiva
(3) Ley de complemento
(4) Ley de Identidad
Negación.
2.11 Demuestre las leyes de DeMorgan: (a) ~( p ^ q) ≡ ~ p ν ~ q; (b) ~( pν q) ≡ ~ p ^ ~ q.
En cada caso construya las tablas de verdad requeridas.
(a)
p q p ^ q ~ (p ^ q) ~ p ~ q ~ p ν ~ q
V V
V
F
F
F
F
V F
F
V
F
V
V
F V
F
V
V
F
V
F F
F
V
V
V
V
(b)
p
V
V
F
F
2.12
q pν q
V
V
F
V
V
V
F
F
~( pν q)
F
F
F
V
~p ~q ~p^~q
F
F
F
F
V
F
V
F
F
V
V
V
Verifique ~ ~ p≡ p
p
V
F
~q ~~p
F
V
V
F
2.13 Use los resultados de los problemas 2.11 y 2.12 para simplificar los siguientes enunciados.
(a)
(b)
(c)
(d)
No es cierto que su madre sea inglesa o que su padre sea francés.
No es cierto que él estudie física pero no matemática.
No es cierto que las ventas estén bajando y los precios subiendo.
No es cierto que no esté haciendo frió o que esté lloviendo.
Informática I. Versión 1.0 Agosto de 2004
27
Universidad Autónoma de Occidente
(a) Sea p “Su madre es inglesa” y sea q “Su padre es Francés”. Entonces el enunciado dado es
~ ( pν q ). Pero ~ ( pν q ) ≡ ~ p ^ ~ q. Por lo tanto, el enunciado dado es lógicamente
equivalente con el enunciado “Su madre no es inglesa y su padre no es francés”.
(b) Sea p “El estudia fisica” y q “El estudia matemáticas”. Entonces el enunciado dado es
~ ( p ^ ~ q).pero ~ (p ^ ~ q) ≡ ~ pν ~ ~ q ≡ ~ p ν q. Así que el enunciado dado es lógicamente
equivalente al enunciado “El no estudia fisica o estudia matemáticas”.
(c) Como ~ (p ^ q) ≡ ~ p ν ~ q, el enunciado dado es lógicamente equivalente al enunciado “Las
ventas estan subiendo o los precios estan bajando”.
(d) Como ~ (~ p ν q) ≡ p ^ ~ q, el enunciado dado es lógicamente equivalente al enunciado “Esta
haciendo frió y no esta lloviendo”.
Condicionales y Bicondicionales.
2.14 Escriba de nuevo los siguientes enunciados sin usar la condicional.
(a) Si hace frió, él se pone sombrero.
(b) Si la productividad sube, los sueldos suben.
Recuerde que “Si p entonces q” es equivalente con “No p o q”; o sea, p → q ≡ ~ p ν q.
(a) No está haciendo frío o él se pone el sombrero.
(b) La productividad no sube o los sueldos suben.
2.15 (a) Demuestre que “p implica q y q implica p” es lógicamente equivalente con la bicondicional
“p si y sólo si q”; o sea, (p → q) ^ ( q → p) ≡ p ↔ q
(c) Demuestre que la bicondicional p ↔ q se puede escribir en términos de las tres conectivas
originales ν, ^ y ~.
(a)
p
V
V
F
F
q
V
F
V
F
p↔q
V
F
F
V
p→q
V
F
V
V
q →p
V
V
F
V
(p → q) ^ ( q → p)
V
F
F
V
(c) Ahora p → q ≡ ~ p ν q y q → p ≡ ~ qν p; por lo tanto por (a)
p ↔ q ≡ ( p → q) ^ ( q → p)≡ (~ q ν q) ^ (~ q ν p)
Informática I. Versión 1.0 Agosto de 2004
28
Universidad Autónoma de Occidente
UNIDAD 3. HERRAMIENTA DE PROGRAMACIÓN.
3.1 Introducción
Aunque el concepto de orientado a objetos, se ha asociado al desarrollo de software, realmente, este es
una forma de concebir el mundo, de manejar conceptos y de entender el funcionamiento de sistemas,
sin embargo, para el objetivo del presente módulo, se tratará solamente la acepción de orientado a
objetos como paradigma de programación.
El paradigma orientado a objetos se asoció durante mucho tiempo con los lenguajes y la programación
orientada a objetos, sin embargo, en la actualidad, el uso de objetos debería incluir tanto el análisis
como el diseño orientados a objetos, el uso de bases de datos y en general, la ingeniería de software
orientada a objetos.
Aunque no intencionalmente, la programación orientada a objetos implica un mayor grado de análisis,
ya que de alguna forma deben estar definidas las clases, atributos y métodos que se van a
implementar. Por ende, al aumentar el tiempo dedicado al análisis y concepción del software, el
tiempo de las otras etapas se reduce.
3.2 Origen del paradigma Orientado a Objetos
Orientado a Objetos es un término que empezó a acuñarse a finales de los 80's, cuando la
programación requería nuevos paradigmas, nuevas formas de interpretarse. Durante los 90's tomó gran
fuerza, pero indiscutiblemente son las dos últimas décadas las que han empezado a recoger los frutos;
en otros países ya la programación orientada a objetos es un hecho y algunos programadores no
podrían pensar en otra forma de desarrollar software.
Autores de gran reconocimiento empezaron a trabajar de manera aislada explorando este nuevo
paradigma, logrando avances tanto en lenguajes de programación como en técnicas apropiadas de
análisis y diseño. Ejemplo de ello son los métodos propuestos por Grady Booch, Ivar Jacobson o
James Rumbaugh entre otros.
3.2.1 Definición de Orientado a Objetos
El concepto de orientado a objetos está relacionado con otros múltiples conceptos: la programación,
las interfaces de usuario y la representación jerárquica de hechos, tienen todos orientación a objetos.
Entonces, ¿cómo podría definirse este término?.
Una definición bastante general de objeto es: todo aquello que tiene limites definidos. En ese orden,
los libros, las sillas, las personas, los animales, las empresas, son todos objetos.
Algunas personas afirman que la orientación a objetos es la forma natural de nuestro aprendizaje.
Cuando estamos pequeños se nos enseña a distinguir y agrupar objetos acorde a sus características y/o
comportamientos y es por ello que logramos distinguir una silla de un caballo aunque ambos tengan
patas.
La programación orientada a objetos es un "estilo" de programación bajo el cual se divide el problema
a solucionar en los objetos que lo componen. Luego se verá que cada objeto de estos contiene
atributos y métodos que permiten su interacción y la ejecución de diversas tareas para cumplir el
propósito del programa.
Existen muchos lenguajes que permiten realizar la programación orientada a objetos, entre ellos se
destacan Smalltalk, Java, C++, Object Pascal, Eiffel.
Informática I. Versión 1.0 Agosto de 2004
29
Universidad Autónoma de Occidente
3.3 Breve historia de los estilos de Programación
Desde el principio de la programación se han intentado muchos métodos y procedimientos para lograr
una programación fácil y eficiente.
El primer enfoque, si se puede llamar así, es la programación no estructurada o "programación
espagueti", bajo la cual el programador se sienta frente al computador y empieza a escribir líneas de
código (instrucciones) sin estructura alguna, resultando en un programa largo, difícil de entender y
aun más difícil de modificar.
El primer enfoque formal que se formalizó fue el enfoque procedural (o procedimental), que se
podría resumir como "Usted decide qué procedimiento quiere, y usa el mejor algoritmo que pueda
encontrar". Aunque este enfoque resultaba muy práctico para resolver problemas particulares, no así
cuando se quería reutilizar parte del código o emplear ciertas funciones en otros programas. En
resumen, el enfoque procedural no permitía mejorar la productividad de la construcción del software
por sus características particulares.
Surge entonces un segundo enfoque o paradigma, la programación modular (o funcional). Para esta
época ya se ha incrementado visiblemente el tamaño de los programas desarrollados, lo cual genera
problemas adicionales de productividad. El enfoque de programación modular es algo como "Decide
los módulos que quieres, de forma que las partes del programa y los datos queden ocultos tras los
módulos". La intención primordial de este enfoque es dividir el problema (programa necesario) en
partes independientes pero relacionadas, que se puedan solucionar de manera separada.
La programación modular propicia la reutilización de código, ya que existen partes (módulos) que
podrían ser empleadas en otros programas, siempre que se requiera la misma utilidad. Esta idea,
aunque en apariencia buena, no surtió mucho efecto ya que los programadores normalmente se
preocupaban por el código pero no por los datos y, normalmente, los módulos requerían de datos que
estaban fuera de ellos.
En un intento por mejorar la concepción modular surgen los llamados tipos abstractos de datos o
TADs, los cuales intentan agrupar, en la misma estructura, los datos necesarios y las operaciones
requeridas para su manejo.
Sigiuendo el concepto de TADs pronto se encontró otro mecanismo para lograr que se crearan
unidades independientes, que permitieran la reutilización de código, y la programación por
componentes; ahora se podría "armar" un programa, tal como se arma un computador o una nevera,
bastaría conseguir las piezas adecuadas y establecer los enlaces necesarios. A este novedoso enfoque
se le conoce como programación orientada a objetos.
La programación orientada a objetos presenta múltiples ventajas. Empecemos por decir que los
programas ahora estarán compuestos por objetos. Cada objeto, a su vez, está compuesto por los datos
o características que lo distinguen y los métodos o procedimientos necesarios para su manipulación.
3.4 Definiciones de clases y objetos
Todos los estilos o enfoques de programación se encuentran basados en un marco referente, de la
misma forma todas las técnicas orientadas a objetos se basan en un marco, que Grady Booch ha
llamado el Modelo de Objetos.
3.4.1 El Modelo de Objetos
El modelo de Objetos, según Booch, se compone de cuatro elementos esenciales, sin los cuales
perdería la propiedad de orientación a objetos. Estos son:
•
Abstracción
Informática I. Versión 1.0 Agosto de 2004
30
Universidad Autónoma de Occidente
•
•
•
Encapsulamiento
Modularidad
Jerarquía
Igualmente incluye otros elementos que, sin ser esenciales, resultan bastante útiles dentro de este
estilo de programación:
•
•
Tipos
Concurrencia
La adecuada comprensión de estos conceptos no es ni exclusiva ni elemental para programar
orientado a objetos. Sin embargo, si no se toman en cuenta estos elementos, la programación orientada
a objetos dejaría de emplear todo el poder que otorgan los objetos.
3.4.1.1 Abstracción
El primer concepto fundamental del paradigma orientado a objetos es la abstracción. Una definición
bastante apropiada del término abstracción es la dictada por Booch:
"Una abstracción denota las características esenciales de un objeto, que lo distingue de todas las
otras clases de objetos y lo provee de conceptos definidos, relativos a la perspectiva del usuario".
Dos cosas importantes deben resaltarse aquí. La primera es que lo que aprendemos, realmente son
abstracciones de la realidad: la idea que tenemos de una mesa, por ejemplo, releva las características
básicas de ésta, permitiéndonos diferenciarla de una silla o de un sofá aunque puedan ser parecidos.
La segunda idea importante, es que las abstracciones dependen de la perspectiva del usuario:
diferentes personas tienen diferentes abstracciones de los objetos, dependiendo de su experiencia e
interés particular.
Actividad #1: Describa las abstracciones que usted posee de computador, mesa, cama, gato.
3.4.1.2 Encapsulamiento
Una característica esencial de los objetos es el encapsulamiento, por la cual, cada objeto mantiene
oculto su interior. Al tratar un objeto como una “caja negra”, los otros objetos que interactúan con él
no requieren conocimiento alguno sobre la forma como opera internamente, requiriendo sólo el
conocimiento de los parámetros necesarios para dicha interacción.
Si los objetos no mantienen el encapsulamiento, se estaría violando uno de los principios básicos de la
orientación a objetos.
La definición original de Booch plantea: "Encapsulamiento es el proceso de compartimentalizar los
elementos de una abstracción, que constituyen su estructura y comportamiento”.
Una ventaja adicional del encapsulamiento se refiere a que el interior de los objetos puede cambiarse
(mejorarse) sin que se requieran cambios en la interfaz que éstos mantienen con otros objetos.
Actividad #2: Enumere 10 elementos que usted emplea normalmente sin conocer realmente cómo
realizan su funcionamiento, pues ellos están encapsulados.
3.4.1.3 Modularidad
La modularidad es un concepto muy antiguo. Aunque es válido para la orientación a objetos no es
exclusivo de ésta. Meyers mencionó la ventaja de la modularidad como: "La acción de partir un
programa en componentes individuales puede reducir su complejidad en algún grado.... aunque la
Informática I. Versión 1.0 Agosto de 2004
31
Universidad Autónoma de Occidente
partición de un programa es útil por esto, una justificación más poderosa para partir un programa es
que él sea un número de límites bien definidos y documentados. Estos límites o interfaces son
invaluables en la comprensión del programa".
La modularidad es básicamente la división en partes de un programa de software (para nuestro caso),
considerando que estos módulos deben mantener la cohesión y el acoplamiento adecuado.
Actividad #3: Normalmente las cosas que nosotros empleamos se encuentran compuestas de partes
(al menos eso dice la Teoría General de Sistemas). Intenta determinar las partes que componen: una
bicicleta, un computador, una casa.
3.4.1.4 Jerarquía
La jerarquía se puede entender como la clasificación u ordenamiento de las abstracciones, esto
permite asociar unos objetos con otros.
Existen dos clases básicas de jerarquías (o clasificaciones), la que corresponde a es parte de, llamada
también jerarquía de partes. Por ejemplo, el manubrio es parte de la bicicleta, o la RAM es parte del
computador. La otra jerarquía es la que corresponde a es un, llamada también jerarquía de tipos. Por
ejemplo, La vaca es un mamífero, la silla es un mueble.
Actividad #4: Intente establecer la jerarquía entre estos elementos:
Impresora, Bandeja, Epson Stylus, Cartucho, Impresora de Burbuja, Impresora Laser, Toner, Panel de
Mando, Conector, HP LaserJet.
Motor, Puerta, Mazda 323, Daewo Lanus, Automóvil, Llantas, Bujías, Tanque de Gasolina.
3.4.1.5 Tipos
Los tipos son la representación de las jerarquías de tipos. Cuando varios elementos se agrupan de
acuerdo a ciertas características específicas que ellos guardan en común, se dice que corresponden a
un mismo tipo.
Los tipos, definidos por Booch, son "la parte fundamental de la clase de un objeto, de forma que los
objetos de tipos diferentes no pueden ser intercambiados, o a lo más pueden ser intercambiados sólo
en forma muy restringida".
Actividad #5: Es normal que cada cosa que conocemos la caractericemos como perteneciente a un
tipo particular. En qué tipo caracterizaría usted los siguientes objetos: casa, computador, vaca, perro,
silla, cuaderno, libro, universidad.
3.4.1.6 Concurrencia
Normalmente los objetos deben realizar tareas simultáneas, sin que unas afecten a otras. A estos
requerimientos de ejecución de varias tareas se les conoce como concurrencia.
Booch la define como "La propiedad que distingue un objeto activo de uno que no está activo",
entendiendo un objeto activo como una abstracción del mundo real que puede representar un hilo de
control separado (una ruta diferente de ejecución).
Actividad #6: Muchos de los sistemas (computacionales o no) que encontramos en la vida diaria
pueden realizar procesos concurrentes (varias cosas al tiempo), intente clasificar los siguientes
sistemas como concurrentes o no: un computador con windows, un computador con linux, una
persona, un cajero electrónico, una máquina de hacer café, un microondas.
Informática I. Versión 1.0 Agosto de 2004
32
Universidad Autónoma de Occidente
3.4.2 Definiciones de Orientación a Objetos
Cuando nos referimos específicamente a la programación orientada a objetos, se emplean los
conceptos vistos a través de términos que hacen referencia al programa y las partes con las que se
establece.
3.4.2.1 Clases y Objetos
El concepto de objetos es para muchos la forma "normal" de asociar las cosas de la vida con nombres.
Cuando iniciamos nuestra educación, empleamos procesos difíciles de asociación de características y
modelos a nombres determinados.
Una clase es un concepto que incluye características o atributos (datos), y procedimientos de una
entidad del mundo real. Ejemplos de clases son: Mueble, Auto, Medio de Transporte, Edificación, etc.
De otra parte, se entiende que las clases son generalizaciones de los objetos, o lo que es lo mismo, los
objetos son instancias de clase. Ejemplos de objetos son: La silla del rector, el carro de Pedro, El
asiento rojo, etc.
Los objetos poseen ciertas características que los hacen particulares. Tales características son:
•
•
•
•
•
•
Tiene un estado (atributos o características)
Tiene un comportamiento (métodos asociados)
Tiene una identidad (ocupa un lugar en memoria)
Tiene un ciclo de vida
Tiene una visibilidad
Se relaciona y colabora con otros objetos
3.4.2.2 Atributos
Los atributos de una clase (y por ende, de un objetos) son las características relevantes de esta. Como
se puede suponer, los atributos de la clase se determinan de acuerdo al problema o situación que se
desea tratar; es decir, dependen de la abstracción que se haga del objeto.
Por ser los objetos instancias de las clases, contienen todos los atributos de éstas.
Por ejemplo:
• La clase silla: tiene como atributos la clase, el número de patas, el tipo de tapizado, el estilo, el
material, la fecha en que fue fabricada.
• La clase carro: tiene como atributos el número de puertas, la marca, el modelo, el precio.
3.4.2.3 Operaciones, métodos y servicios
Las clases, además de atributos, contienen los procedimientos que pueden manipular o procesar estos
datos. A estos procedimientos se les conoce como operaciones, métodos o servicios.
Estos métodos exhiben el comportamiento posible del objeto. Este comportamiento ocasionará que el
objeto mismo cambie de un estado a otro.
Por ejemplo:
• La clase auto: tiene como métodos o servicios, arrancar, parar, frenar, aumentar velocidad,
disminuir velocidad.
• La clase computador: tiene como métodos o servicios, encender, iniciar, arrancar programa.
Informática I. Versión 1.0 Agosto de 2004
33
Universidad Autónoma de Occidente
3.4.2.4 Identidad
Los objetos deben ser creados y durante su creación deben recibir un nombre y una asignación de
espacio en memoria. En este sentido, los objetos, a diferencia de las clases, existen dentro del
computador por un tiempo que determinará el programador.
3.4.2.5 Ciclo de Vida
Como se dijo anteriormente, los objetos cambian de estado dependiendo del comportamiento que
desarrollen. A todos estos cambios de estado por los que pasa (o puede pasar) un objeto desde que es
creado hasta que muere, se le denomina ciclo de vida.
Actividad #7: Establezca atributos y métodos para cada uno de los conceptos mencionados a
continuación, y especifique si son clases u objetos. Si es un objeto, indique a qué clase pertenecería:
árbol, manzana, casa, Corporación Universitaria Autónoma de Occidente, Secretaría de Gobierno,
Amigo, Estudiante, Perro, Ferrari.
3.4.2.6 Relaciones con otros objetos
Los objetos han sido determinados como partes de la solución de un problema y ello implica que
tengan que relacionarse para cumplir su cometido. Las relaciones entre los objetos pueden ser de
muchas clases:
Mensajes
Los mensajes activan las operaciones y métodos de cada objeto. Un objeto envía a otro un mensaje, en
el cual se indica el destino, la operación requerida y los parámetros que debe incluir.
Los mensajes son el corazón del comportamiento del sistema, ya que le indica a los objetos
comunicarse entre ellos para ejecutar sus operaciones.
Normalmente la clase de relaciones que se establecen a través de los mensajes se les denomina
relaciones de uso, ya que un objeto usa a otro.
Herencia
Las clases pueden heredar de otras clases sus atributos y métodos. La herencia responde a la necesidad
de hacer clases nuevas que contienen características similares (o iguales) a las de otra clase ya
existente.
Parte (mucho) del arte de programar orientado a objetos es determinar la mejor forma de estructurar el
programa “economizando” clases. Conviene aclarar que al emplear herencia, se reduce el número de
líneas a implementar.
Algunos lenguajes como Java resultan ser muy estrictos en términos de herencia, ya que todas las
clases deben heredar de alguna. por lo anterior, JAVA tiene una "superclase" llamada Object, de la
cual se derivan todas las restantes.
Cuando una clase hereda de otra, puede variar los atributos y métodos que ha heredado, logrando su
propia identidad respecto a la clase de la cual se originó.
Algunos Lenguajes Orientados a Objetos, permiten que una clase hereda de dos o más, lo cual se
conoce como herencia múltiple.
Del concepto de herencia, se deriva el concepto de jerarquía de clases, que presenta esquemáticamente
la herencia entre las clases.
Informática I. Versión 1.0 Agosto de 2004
34
Universidad Autónoma de Occidente
Agregación
Cuando un objeto o clase se encuentra compuesta por otros, se dice que existe una relación de
agregación entre ellos.
Actividad #8: Indique que clase de relación existe entre cada conjunto de elementos (considerando
que todos son objetos y que guardan alguna relación).
Procesador, memoria, unidad de disco, diskette, computador, usuario.
Casa, sala, Edificación, Biblioteca pública, sillas, mesas, mesa de comedor.
Polimorfismo
El Polimorfismo es una característica propia de los objetos, que permite que operaciones diferentes
posean el mismo nombre
Sobrecarga
La sobrecarga es una clase de polimorfismo, en la cual los métodos se diferencian básicamente por la
clase de parámetros que reciben. Al recibir el mensaje el objeto, mediante los parámetros identifica
automáticamente la operación que se desea ejecutar; esto se conoce como sobrecarga de métodos. Por
ejemplo: imprimir(factura), imprimir(reporte), imprimir(paz y salvo); aunque la función (método) es
la misma, dependiendo el tipo de argumento que recibe se realizarán diferentes labores.
Algunos lenguajes, como C++, permiten además lo que se llama sobrecarga de operadores (operator
overloading) gracias a la cual se pueden redefinir los operadores aritméticos básicos ( +, - , * , / ). Por
ejemplo: 3 + 5 sumará enteros, mientras "Hola" + " amigos", concatenará cadenas.
Sobreescritura
La sobreescritura corresponde a la otra clase de polimorfismo, llamado también polimorfismo de
generalización. En éste, los métodos heredados de una superclase pueden ser sobrescritos para
elaborar funciones diferentes. Sin embargo, NO se puede variar la signatura (ó firma) del método; es
decir; NO se puede cambiar el nombre, el tipo de los parámetros, el número de parámetros que recibe
y el tipo de dato que devuelve.
Informática I. Versión 1.0 Agosto de 2004
35
Universidad Autónoma de Occidente
Ejercicios
1. Indique si cada uno de los enunciado presentados a continuación es verdadero o falso y justifique
su respuesta:
a. Al programar orientado a objetos, lo que se definen son clases.
b. Debido al encapsulamiento, los métodos de un objeto no pueden ser usados por otro.
c. La programación orientada a objetos facilita la reutilización de código.
d. La relación de herencia indica que un objeto es parte de otro.
e. Un objeto sólo puede pertenecer a una clase.
f. El polimorfismo permite que varios métodos tengan igual nombre.
g. La programación “espagueti” se puede considerar modular.
h. La programación procedural admite la herencia.
i. Los métodos de una clase se implementan siguiendo las directrices de la programación
estructurada
j. La herencia especifica que una clase posee los mismos métodos y atributos de la clase de la
cual hereda.
k. Auto es una instanciación de Medio de Transporte.
l. Pedro es un objeto de la clase Persona.
m. Pedro es una clase.
n. Atributos de auto son rojo, grande y mazda.
o. Métodos de Teléfono son establecer comunicación y timbrar.
p. Manzano hereda de Árbol.
q. Manzana hereda de Manzano.
r. Tablero es parte de Profesor.
s. Otoño es una clase de Estación.
t. Windows hereda de Sistemas Operativos.
2. Complete las siguientes frases con la palabra adecuada
a.
La sobrecarga es la implementación de _____________________________________.
b.
Un objeto es una _________________de una clase.
c.
La programación __________________________________se basa en partes, cada una con
características y funciones específicas.
d.
Cuando una clase redefine un método con la misma signatura que tenía en la clase de la
cual heredó se denomina __________________.
e.
La herencia puede ser _________________________o múltiple.
f.
Las características esenciales que distinguen a un objeto se conocen como
____________________del objeto.
g.
La primera técnica formal de programación conocida fue la programación
_______________________________________.
h.
Si un sistema puede realizar varias tareas al tiempo, se dice que tiene procesamiento
________________.
i.
Los __________ son estructuras de datos que dieron origen a los objetos.
j.
Memoria ___________________ de Computador.
k.
IBM NetVista es ____________________ de Computador.
l.
Fuente de Poder es ______________ de Computador.
m.
Maria Isabel ____________ de clase Estudiante
n.
La clase persona usa la clase _________________
o.
La clase perro _______________ la clase animal.
p.
Matemáticas es un objeto de la clase _________________.
q.
_____________ es un objeto de clase pescado.
r.
Arroz con pollo ______________ comida.
Informática I. Versión 1.0 Agosto de 2004
36
Universidad Autónoma de Occidente
3.5 Características básicas del lenguaje Java
3.5.1 Historia de JAVA
Una de las áreas reconocidas de avance para la computación e informática, es la de los dispositivos
electrónicos inteligentes. En razón de esto, Sun Microsystems financió un proyecto de investigación
interno con el nombre Proyecto Green en 1991. Uno de los resultados de este poyecto fue un lenguaje
basado en C y C++, llamado Oak, creado por James Gosling, Patrick Naughton, Chris Warth, Ed
Frank y Mike Sheridan. Poco después se descubrió que ya existía un lenguaje con este nombre, así
que surgió el nombre de JAVA (una clase de café). El prototipo original, desarrollado en 18 meses,
fue mejorado con la ayuda de muchas personas, lo cual tomó más de 3 años.
El propósito inicial con el proyecto fue crear un lenguaje independiente de la plataforma, que
facilitara el uso en diferentes dispositivos electrónicos. Hasta el momento, C y C++ eran los lenguajes
más empleados, sin embargo no permitían la facilidad requerida ya que debe proveerse del compilador
especifico para la CPU necesaria, lo cual puede llevar algún tiempo de construcción. Sin embargo,
mientras se desarrollaba JAVA apareció el otro elemento que formaría parte esencial de su
construcción, el World Wide Web; de no ser por este aspecto, JAVA probablemente no habría pasado
de ser un lenguaje más empleado por los diseñadores de hardware en sus laboratorios.
Es conveniente aclarar que aunque JAVA basó su desarrollo en C y C++, de ninguna manera es una
versión avanzada de estos, no es compatible con alguna versión de C++, ni intenta reemplazarlo; más
bien maneja otras características importantes que se requerían en su momento, dando a los
programadores un ambiente familiar.
Respecto a la programación, JAVA presenta muchas ventajas, como mencionan Naugthon y Schildt:
"Java fue diseñado, probado y refinado por programadores auténticos. Es un lenguaje que se basa en
las necesidades y experiencia de la gente que lo ha inventado.... Java es un lenguaje coherente y
lógicamente consistente.... Java le permite al programador tener el control total, excepto en aquellas
limitaciones impuestas por Internet. Si uno programa bien, el programa lo reflejará; si uno programa
mal, el programa también lo reflejará. Dicho de otro modo, Java no es un lenguaje con ruedas de
entrenamiento, sino que es un leguaje para programadores profesionales".
La intención de Sun Microsystems con el desarrollo de JAVA no fue el lucro, sino facilitar sus
propias labores en la construcción de dispositivos de hardware. Por tanto, el JAVA y sus herramientas
asociadas siempre han sido de dominio público, de forma que basta entrar al sitio de sun
(www.java.sun.com), para obtener la versión actualizada del JDK (Java Development Kit).
Exactamente, en el sitio web http://java.sun.com/downloads , usted puede descargar el kit de
desarrollo de Java.
3.5.2 Características Básicas de JAVA
JAVA posee muchas características importantes. A continuación se mencionarán aquellas más
sobresalientes.
Orientado a Objetos puro
Muchos lenguajes tienen como característica ser orientado a objetos, lo cual implica que permitan
crear clases, manejar herencia y mantener el encapsulamiento. No obstante, existen dos clases de
lenguajes orientados a objetos:
aquellos que permiten las características del manejo de objetos, pero también mantienen
características de otros estilos de programación (v.g. programación procedimental); a estos lenguajes
se les conoce normalmente como híbridos. Un ejemplo clásico de este tipo de lengujes es el C++ que,
además de soportar el manejo de objetos, también permite la escritura de código propio de C.
Informática I. Versión 1.0 Agosto de 2004
37
Universidad Autónoma de Occidente
La otra clase de lenguajes son los denominados puros, tal como Java o Smalltalk, en donde sólo se
pueden manejar clases y objetos. Por lo tanto, cualquier fragmento de código que se quisiera escribir
debe formar parte de una clase.
Simple
Una preocupación de SUN es mantener el lenguaje simple. Desde su comienzo, las instrucciones
propuestas, similares al C, tienen por objeto facilitar al programador su comprensión, incluso con
estándares muy sencillos como que las clases se escriben iniciando en mayúscula y los objetos con
minúsculas.
Con miras a esto, se quitaron algunos aspectos que C++ maneja; tales como sobrecarga de operadores,
herencia múltiple y apuntadores; por considerar que no aportaban de manera significativa en relación
con la complejidad que revestían y se adicionaron otros aspectos para facilitar la vida del
programador, tal como el colector de basura.
Distribuido
Java ha sido diseñado para interactuar de manera sencilla con el conjunto de protocolos TCP / IP
(manejados en Internet), de manera que las aplicaciones de Java puedan abrir y acceder a objetos a
través de URLs de manera tan sencilla como si estuvieran en la misma máquina.
Robusto
La robustez de un software es una de las características de calidad más importantes y se refiere a la
posibilidad del software de prevenir posibles errores que, de ocurrir, podrían interrumpir la ejecución
adecuada del mismo.
Java se preocupa por ello y hace un especial énfasis en la detección de problemas, chequeo dinámico
(en tiempo de ejecución) y eliminar posibles situaciones de error.
Seguro
Una de las intenciones de Java es que éste sea empleado en entornos de red y distribuidos, pero se
debe tener conciencia de la importancia de la seguridad en ambientes de este estilo. Por ello, el
lenguaje mismo provee mecanismos apropiados para evitar la construcción de virus o trampas.
También tiene mecanismos de autenticación basados en encriptamiento de llaves (SSL).
Arquitectura Neutral
Para que las aplicaciones que se hacen en java puedan efectivamente viajar a través de la red, el
lenguaje debe proveer mecanismos que permitan ejecutar el software en cualquier sistema,
independiente de su plataforma; por ello, Java provee una archivo en un formato de arquitectura
neutra que puede ser ejecutado en diferentes procesadores con la ayuda del adecuado sistema de
ejecución de java.
Portable
La arquitectura neutra es la base para la portabilidad, pero para lograr que el software sea portable se
requiere mucho más. Por ejemplo, el manejo de los diferentes tipos de datos y las interfaces gráficas
deben ser independientes de la plataforma en que se ejecutan.
El sistema Java mismo es altamente portable, el compilador está escrito en JAVA y el runtime
(ejecutador) está escrito en ANSI C.
Interpretado
El interpretador de Java puede ejecutar directamente los bytecodes (código de bytes, generado
después de la compilación) directamente en la máquina en la cual se encuentra instalado. Muchas
Informática I. Versión 1.0 Agosto de 2004
38
Universidad Autónoma de Occidente
personas han visto esta característica como una desventaja de Java, debido a que el proceso de enlace
(link, p. ej. en C / C ++) es mucho más rápido y liviano. Sin embargo, debe reconocerse que la
interpretación ayuda en los procesos de depuración.
Alto desempeño
Aunque el desempeño del interpretador comúnmente es suficiente, si se requiere un mayor nivel de
desempeño puede traducirse el bytecode a un código particular para la máquina en la cual se ejecuta.
Multihilos
Multihilo es es la forma de construir aplicaciones de manera que puedan realizar varias actividades
(hilos) al mismo tiempo. Java tiene primitivas básicas que permiten monitorear y usar los hilos; esto
logra una mejor interacción y un comportamiento de tiempo real (limitado sólo por la máquina en la
cual está corriendo).
Dinámico
Java fue diseñado para adaptarse a un entorno cambiante. El hecho de manejar objetos permite que los
cambios que se requieran en un software determinado no afecten de manera significativa los procesos
existentes.
Ver mas en www.java.sun.com/docs/white/langenv/
Actividad #9: Tome dos de las características básicas de JAVA, investigue más al respecto indicando
en qué consisten exactamente y qué otros lenguajes de programación tienen estas características (una
u otra).
3.5.3 La estructura de JAVA
¿Compilado o Interpretado?
Una de las primeras inquietudes que surgen cuando se empieza a interactuar con Java es si realmente
es un lenguaje compilado o interpretado; la respuesta es sencilla: los dos.
La forma de operar de Java es un tanto diferente a la forma en que operan otros lenguajes más
tradicionales y esto es, justamente, lo que permite que los programas desarrollados en Java puedan
emplearse en diferentes plataformas.
El siguiente gráfico, presenta la forma como se debería procesar un programa en Java.
Procesamiento de un programa en JAVA ( Fuente: Java Tutorial)
Como se puede observar, el programa fuente (myProgram.java) debe ser compilado para crear el
programa en bytecode (myProgram.class), el cual puede ser ejecutado en cualquier plataforma, ya que
Informática I. Versión 1.0 Agosto de 2004
39
Universidad Autónoma de Occidente
la máquina que lo ejecutará en particular tiene su intepretador (diferente para cada máquina) que lee,
interpreta y ejecuta cada una de las instrucciones que encuentra en el bytecode.
Plataforma de Java
Como plataforma se conoce al entorno Hardware – Software en el cual se ejecuta un programa.
Normalmente se asocia con el sistema operativo y la máquina sobre la que este corre; así, se tienen
como plataformas: Windows (en cada una de sus formas), MacOS, Linux, Uníx, Solaris, etc.
La plataforma de Java se compone de dos elementos básicos: Java Application Programming Interface
(Java API) y la Java Virtual Machine (JVM). Su ubicación se presenta en el siguiente gráfico.
Plataforma de Java (Fuente: Java Tutorial)
•
•
El Java Virtual Machine es el intérprete de Java. Como se dijo anteriormente, existen un JVM
para cada plataforma y es el que permite que un programa sea escrito una vez y ejecutado en
varias plataformas sin requerir cambios.
La API de Java o Interface de Programas de Aplicación es una colección de componentes de
software que provee diferentes utilidades para el programador, tal como la interfaz gráfica de
usuario (GUI). La API se encuentra organizada en librerías que contienen clases o interfaces,
conocidas como paquetes (packages). El siguiente gráfico muestra lo que incluye el Java 2
SDK (Standard Developer Kit).
Contenido del Java 2 SDK (Fuente: Java Tutorial)
El JRE o Java 2 Runtime Environment es: la máquina virtual, la plataforma de clases y los archivos
de soporte. El SDK (Standard Developer Kit) incluye el JRE y las herramientas de desarrollo como
compiladores y depuradores.
3.5.4 Instalación de JAVA
Java pertenece al software de dominio libre, es decir que cualquier persona puede entrar al sitio de
Internet y bajarlo sin pagar ningún costo.
• Para iniciar la instalación de Java, entre al sitio http://java.sun.com/downloads y escoja la
versión apropiada de JDK acorde a su plataforma.
Informática I. Versión 1.0 Agosto de 2004
40
Universidad Autónoma de Occidente
•
•
•
•
•
El archivo j2sdk-1_4_2_05-windows-i586-p debe quedar en su disco, este es el instalador del
SDK. Al ejecutar este programa, se instalará el Java en su disco, normalmente se instala en el
directorio C:\j2sdk1.4.2_05\ (NOTA: los nombres de los archivos podrían variar
dependiendo de la versión de Java disponible).
Aunque no es obligatorio, es mejor actualizar el Path (camino) del computador, para permitir
que siempre encuentre los programas necesarios sin importar el directorio en el cual se
encuentre ubicado el programador. Para ello,
Puede escoger en el menú de inicio, la opción ejecutar y dar sysedit - Enter, el sistema
presenta varias pantallas, debe escogerse el AUTOEXEC.BAT (este archivo establece algunas
configuraciones iniciales cada vez que se enciende el computador). Busque la instrucción
PATH. Si existe, agrege al final de ésta: ;C:\j2sdk1.4.2_05\BIN
Si no existe, al final del archivo escriba PATH C:\j2sdk1.4.2_05\BIN
Para que este cambio tenga efecto, debe reiniciarse el computador, ó, ejecutar el autoexec.bat.
Ahora puede empezar a utilizar su JDK y hacer sus primeros programas en Java.
Una última recomendación, las instrucciones que se manejarán para la compilación y ejecución se
digitan desde el DOS, por lo que puede ser útil revisar algunas instrucciones básicas de este
antiguo Sistema Operativo. No obstante, se sugiere un editor gratuito de la empresa Xinox
software: JCreator 3.0, el cual puede descargar del sitio web http://www.jcreator.com
3.6 Construcción Básica de una Aplicación
Un programa desarrollado en JAVA pasa por cinco fases para poder ejecutarse: Edición, Compilación,
Carga, Verificación, Ejecución.
Edición
La edición de un archivo corresponde a la escritura del código fuente. Dentro del Kit original de
JAVA no se incluye un editor, por lo que el programador deberá proveerse de uno. Para el propósito
sirve cualquiera. Tomando en consideración que el texto debe ser plano, se recomienda Edit en Dos,
NotePad en Windows o vi en Unix. De nuevo, se sugiere el editor gratuito de la empresa Xinox
software: JCreator 3.0, el cual puede descargar del sitio web http://www.jcreator.com
Debe tenerse en cuenta que los programas de código fuente en JAVA deben tener la extensión .java.
Edición
Disco
Se crea un programa .java
Compilación
La compilación es el proceso por el cual el código fuente es traducido a un código de bytes (bytecode)
que será interpretado durante la etapa de ejecución. Esta operación se realiza mediante el comando
javac, el cual revisa la sintaxis y semántica del programa fuente escrito y, si todo es correcto, creará
un programa con el mismo nombre del programa fuente y la extensión .class1.
Compilación
Disco
Se crea un programa .class
Carga
Para que una aplicación pueda ejecutarse, debe ser cargada, ó, subida a memoria. Lo mismo ocurre
con las aplicaciones de JAVA. El comando java se encargará, en primera instancia, de esta labor
aunque también realiza la verificación y la ejecución.
1
Como se verá posteriormente, puede ocurrir que un archivo .java dé origen a varios archivos .class
Informática I. Versión 1.0 Agosto de 2004
41
Universidad Autónoma de Occidente
Carga
Disco
Se carga el programa a
memoria
Memoria
Verificación
En esta etapa se determina si la aplicación que se desea ejecutar tiene o no errores, principalmente de
seguridad. Esto es muy importante, considerando que las aplicaciones comúnmente son enviadas a
través de Internet.
Verificación
Memoria
Se verifican que el
bytecode sea válido y
aspectos de seguridad
Ejecución
Finalmente, cubiertos todos los pasos, se interpretan las instrucciones del código de bytes,
traduciéndolos a instrucciones que la máquina pueda realizar (lenguaje de máquina).
Interpréte
Memoria
Lee cada instrucción del
bytecode y las ejecuta
Ejemplo de una Aplicación
En Java se pueden desarrollar aplicaciones o applets.
Las aplicaciones pueden ejecutarse en cualquier ambiente, su código es sencillo y no requiere archivos
adicionales.
Ejemplo:
/* Es es un programa de prueba.
La aplicación genera una línea de impresión en la pantalla.
El archivo debe llamarse Bienvenida1.java */
class Bienvenida1 {
// Toda aplicación debe tener un método main( )
public static void main( String args[ ] ) {
System.out.println( "Bienvenido a la Tecnologia Java!!" ) ;
}
}
Observe que:
• Todo programa en JAVA debe contener al menos una clase.
• El archivo del código fuente debe tener el mismo nombre de la clase principal de la aplicación. En
este caso: Bienvenida1.java
• El JAVA es sensible al uso de Mayúsuculas, así que Bienvenida1 y bienvenida1 son dos cosas
diferentes.
• Toda aplicación debe contener, en su clase principal, un método de nombre main( ), con la
signatura (ó firma) presentada.
Informática I. Versión 1.0 Agosto de 2004
42
Universidad Autónoma de Occidente
El siguiente paso es la compilación. Para ello, desde la ventana del DOS, ubique el directorio donde
guardó su archivo con código fuente y digite javac Bienvenida1.java
Si el programa ha generado algún error, revise, corrija y repita la compilación hasta que no genere
errores y quede creado un archivo Bienvenida1.class en su carpeta.
Los pasos de cargar, verificar y ejecutar se realizar con una sola instrucción: java.
Para ejecutar el programa anterior, digite java Bienvenida1 (no debe incluirse la extensión).
Ahora podrá ver la ejecución del programa en la ventana de DOS.
Ejemplo de una Applet
Los applets (aplicacioncitas) son aplicaciones que requieren un entorno WEB para ejecutarse, de
forma que se requiere que estén insertadas en una página WEB para ser vistas.
Ejemplo:
// Un ejemplo de Applet
// El archivo debe llamarse Ejemplo1.java
import javax.swing.JApplet ;
import java.awt.Graphics ;
public class Ejemplo1 extends JApplet {
public void paint( Graphics g ) {
g.drawString( "Ejemplo de applet en java", 25, 25 ) ;
}
}
Observe que:
• Todo applet de JAVA debe contener al menos una clase.
• El archivo del código fuente debe tener el mismo nombre de la clase principal del applet, en este
caso Ejemplo1.java.
• El JAVA es sensible al uso de Mayúsculas, así que Ejemplo1 y ejemplo1 son dos cosas diferentes.
• Los applets requieren de las librerías correspondientes. Para este caso se incluye la librería
javax.swing y la librería java.awt. Dentro de la primera librería se ha escogido una clase
específica: JApplet. Dentro de la última librería se ha escogido una clase específica: Graphics.
• Los JApplets requieren un método llamado paint( )
Como se dijo anteriormente, para ejecutar un applet debe disponerse de una página WEB.
El código de las páginas web está escrito en HTML (Hypertext Markup Language).
Un código apropiado para el programa anterior sería:
<html>
<applet code = "Ejemplo1.class" width = 275 height = 35>
</applet>
</html>
El nombre del archivo puede ser cualquiera con extensión .html. Lo recomendable sería que tuviera el
mismo nombre del applet de JAVA.
Informática I. Versión 1.0 Agosto de 2004
43
Universidad Autónoma de Occidente
Observe que:
• El código HTML siempre inicia y termina con html.
• Las terminaciones de las secciones siempre son la misma palabra de inicio con una diagonal (/)
antepuesta.
• El ancho y alto especificado para el applet corresponden al tamaño de la ventana donde se
ejecutará el applet.
La compilación para un applet es igual que para una aplicación; es decir, desde la ventana de DOS
ubique el directorio donde guardo su archivo con código fuente y digite javac Ejemplo1.java
Una vez se disponga del programa .html y el .class (en el mismo directorio), hay dos formas de
correrlo:
1) En un Browser (Netscape, Explorer, etc.) abra el archivo .html que creó, esto activará la carga,
verficación y ejecución del applet. Debido a que el applet está trabajando con swing (un
manejador de GUI relativamente nuevo en Java) algunos manejadores no lo soportan, por lo que
es común que no pueda verse nada en el browser.
2) Empleando el appletviewer que posee el JDK. Para ello basta digitar desde la ventana de DOS
appletviewer Ejemplo1.html (suponiendo que su archivo de html se llama Ejemplo1). El Java se
encarga de crear un ambiente simulador de browser donde usted puede observar la ejecución de su
applet sin problema.
Salida:
A continuación, otro ejemplo de Aplicación Java:
Informática I. Versión 1.0 Agosto de 2004
44
Universidad Autónoma de Occidente
Salida:
Ejercicios
Indique si las siguientes proposiciones son verdaderas o falsas, justifique su respuesta.
a.- Java es un lenguaje orientado a objetos híbrido.
b.- La API y la JVM se incluyen en el SDK.
c.- Existen una única JVM para todas las plataformas.
d.- La compilación, carga y verificación de un programa escrito en Java, se realizan en un solo
paso.
e.- El compilador de Java fue desarrollado en C.
f.- Java es una versión actualizada de C++.
g.- Se dice que Java es robusto porque permite al usuario depurar el código fácilmente.
h.- Java se considera portátil porque una vez escrito y compilado el programa puede ejecutarse en
cualquier plataforma.
i.- Los applets son aplicaciones pequeñas que corren a través de un browser.
j.- Java es sensible a mayúsculas.
3.7 Salida de datos estándar
// Ejemplo 1 Esta aplicación Java muestra un mensaje de Bienvenida
// en la salida estandar (pantalla), ó consola Java:
class SalidaBasica1 {
public static void main( String args[ ] ) {
System.out.println( "Bienvenido al curso de Algoritmos con Java 2" ) ;
}
}
// Fin de la clase SalidaBasica1
Salida:
// Ejemplo 2 Esta aplicación Java explica la diferencia entre print y println
class SalidaBasica2 {
public static void main( String args[ ] ) {
System.out.print( "Bienvenido al curso de " ) ;
System.out.print( "Algoritmos con Java 2\n" ) ; // \n es el comando para nueva línea
System.out.println( "Imprime una linea en blanco, ejecuta el retorno de carro y" ) ;
System.out.println( "avanza a la linea siguiente" ) ;
}
}
// Fin de la clase SalidaBasica2
Salida:
Informática I. Versión 1.0 Agosto de 2004
45
Universidad Autónoma de Occidente
3.8 Entrada de datos estándar
// Ejemplo 1 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String)
// desde el teclado.
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica1 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
InputStreamReader isr = new InputStreamReader( System.in ) ;
BufferedReader br = new BufferedReader( isr ) ;
/* Las 2 líneas anteriores habilitan la entrada de datos desde el
teclado. El proceso le puede parecer confuso, pero es necesario que
se vaya familiarizando con él. La primer línea subrayada crea un objeto, que hemos
denominado arbitrariamente isr, de la clase InputStreamReader.
Para crear el objeto isr, se le ha enviado al constructor de la
clase InputStreamReader el argumento System.in (teclado).
La segunda línea subrayada crea un objeto, que hemos denominado arbitrariamente br,
de la clase BufferedReader. Para crear el objeto br, se le ha enviado al
constructor de la clase BufferedReader el argumento isr, el cual es el
objeto que se creó en la primer línea subrayada.
El último objeto creado, br, es el que nos sirve para invocar el método
readLine( ) de la clase BufferedReader. El método readLine( ) lee la
información digitada desde el teclado hasta pulsar la tecla Return
(o Enter, o Intro, etc) y la guarda como una cadena de caracteres (String).
*/
System.out.print( "Escriba su nombre y pulse RETURN: " ) ;
String cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena
// Muestre en consola el nombre ingresado, concatenado con un mensaje:
System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ;
}
}
// Fin de la clase EntradaBasica1
Informática I. Versión 1.0 Agosto de 2004
Salida:
46
Universidad Autónoma de Occidente
// Ejemplo 2 Esta aplicación Java muestra cómo ingresar una cadena de caracteres (String)
// desde el teclado.
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica2 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
/* La línea subrayada habilita la entrada de datos desde el teclado.
Ahora, se han escrito las instrucciones del proceso en una sola línea.
Repasando lo mencionado en el ejemplo anterior (clase EntradaBasica1),
note de nuevo que para recibir los datos vía teclado, debe crear un
objeto (que arbitrariamente hemos llamado br) de la clase BufferedReader.
Observe que al constructor de la clase BufferedReader se le envía como
argumento una nueva instancia (o sea, un objeto) de la clase InputStreamReader.
Para obtener esta nueva instancia de la clase InputStreamReader, se ha
enviado a su constructor la variable de clase 'in' de la clase System.
De nuevo, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader.
El método readLine( ) lee la información digitada desde el teclado hasta pulsar
la tecla Return (o Enter, o Intro, etc) y la guarda como una
cadena de caracteres (String).
*/
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ;
// Declara la variable tipo String (cadena de caracteres)
System.out.print( "Escriba su nombre y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Guarde el nombre en la variable cadena
// Muestre en consola el nombre ingresado, concatenado con un mensaje:
System.out.println( "Hola " + cadena + ", bienvenido a Java 2" ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica2
La salida es similar a la de la aplicación EntradaBasica1.java
// Ejemplo 3 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado.
Informática I. Versión 1.0 Agosto de 2004
47
Universidad Autónoma de Occidente
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica3 {
public static void main( String args[ ] ) throws IOException {
/* Note que antes de la llave de apertura del método main( ), se
debe escribir 'throws IOException' para evitar mensajes
relacionados con el manejo de errores y que impiden la
correcta compilación del programa. */
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres)
int entero ; // Declara la variable entero del tipo int (número entero)
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues
//el método readLine( ) lee la información digitada desde el teclado hasta pulsar
//la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de
//caracteres (String).
entero = Integer.parseInt( cadena ) ;//Convierte de String a entero (int),
//pues el método parseInt( String ) de la clase Integer recibe un parámetro
//String y lo convierte a su equivalente numérico en formato entero (int).
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica3
Salida:
// Ejemplo 4 Esta aplicación Java también muestra cómo ingresar un número entero
// desde el teclado, pero utiliza menos instrucciones.
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica4 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004
48
Universidad Autónoma de Occidente
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
int entero = Integer.parseInt( br.readLine( ) ) ; // Notar que podemos usar
// directamente el método readLine( ) [ llamado desde el objeto br ]
// como argumento del método parseInt de la clase Integer, reduciendo todo a una
// sola instrucción. Además, no es necesario la variable auxiliar deltipo String ni
// declarar por separado la variable 'entero' del tipo int (entero).
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ;
}
// Salga de la Aplicación
// Fin del método main( )
Salida:
}
// Fin de la clase EntradaBasica4
/*
Ejemplo 5 Esta aplicación Java ilustra cómo ingresar más números enteros
desde el teclado, los cuales han sido declarados en los otros
formatos proporcionados por Java para números enteros. */
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica5 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int i ;
long j ;
short k ;
byte m ;
System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ;
Informática I. Versión 1.0 Agosto de 2004
49
Universidad Autónoma de Occidente
i = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ;
j = Long.parseLong( br.readLine( ) ) ;
System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ;
k = Short.parseShort( br.readLine( ) ) ;
System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ;
m = Byte.parseByte( br.readLine( ) ) ;
// Muestre en consola los números digitados:
System.out.println( "Primer numero entero: " + i ) ;
System.out.println( "Segundo numero entero: " + j ) ;
System.out.println( "Tercer numero entero: " + k ) ;
System.out.println( "Cuarto numero entero: " + m ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica5
Salida:
// Ejemplo 6 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado utilizando la clase Integer y su método intValue( )
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica6 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
String cadena ; // Declara la variable cadena del tipo String (cadena de caracteres)
int entero ; // Declara la variable entero del tipo int (número entero)
Informática I. Versión 1.0 Agosto de 2004
50
Universidad Autónoma de Occidente
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
cadena = br.readLine( ) ; // Lee el número como una cadena de caracteres, pues
//el método readLine( ) lee la información digitada desde el teclado hasta pulsar
//la tecla Return (o Enter, o Intro, etc) y la guarda como una cadena de
//caracteres (String).
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( cadena ) ;
// la cadena String se envía al constructor
// Invoca al método intValue( ) de la clase Integer:
entero = i.intValue( ) ;
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica6
Salida:
// Ejemplo 7 Esta aplicación Java muestra cómo ingresar un número entero
// desde el teclado utilizando la clase Integer y su método intValue( )
// Se usarán menos instrucciones
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica7 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero entero y pulse RETURN: " ) ;
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía directamente al constructor
// de la clase Integer
int entero = i.intValue( ) ;
Informática I. Versión 1.0 Agosto de 2004
51
Universidad Autónoma de Occidente
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero entero " + entero ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica7
Salida:
// Ejemplo 8 Esta aplicación Java muestra cómo ingresar números enteros
// desde el teclado utilizando las clases Integer, Long, Short y Byte
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica8 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite el primer numero entero y pulse RETURN: " ) ;
// Crea un objeto, i, de la clase Integer:
Integer i = new Integer( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Integer
int entero1 = i.intValue( ) ;
System.out.print( "Digite el segundo numero entero y pulse RETURN: " ) ;
// Crea un objeto, j, de la clase Long:
Long j = new Long( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Long
long entero2 = j.longValue( ) ;
System.out.print( "Digite el tercer numero entero y pulse RETURN: " ) ;
// Crea un objeto, k, de la clase Short:
Short k = new Short( br.readLine( ) ) ;// la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Short
short entero3 = k.shortValue( ) ;
Informática I. Versión 1.0 Agosto de 2004
52
Universidad Autónoma de Occidente
System.out.print( "Digite el cuarto numero entero y pulse RETURN: " ) ;
// Crea un objeto, m, de la clase Byte:
Byte m = new Byte( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Byte
byte entero4 = m.byteValue( ) ;
// Muestre en consola los números ingresados:
System.out.println( "Primer numero entero: " + entero1 ) ;
System.out.println( "Segundo numero entero: " + entero2 ) ;
System.out.println( "Tercer numero entero: " + entero3 ) ;
System.out.println( "Cuarto numero entero: " + entero4 ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica8
Salida:
// Ejemplo 9 Esta aplicación Java muestra cómo ingresar un número real (de punto flotante)
// desde el teclado.
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica9 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero real y pulse RETURN: " ) ;
double real = Double.parseDouble( br.readLine( ) ) ; /* Notar que podemos usar
directamente el método readLine( ) [ llamado desde el objeto br ]
como argumento del método parseDouble de la clase Double, reduciendo todo a una
sola instrucción.*/
Informática I. Versión 1.0 Agosto de 2004
53
Universidad Autónoma de Occidente
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero real " + real ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
Salida:
// Fin de la clase EntradaBasica9
// Ejemplo 10 Esta aplicación Java también muestra cómo ingresar un número
// real (de punto flotante) desde el teclado.
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica10 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite un numero real y pulse RETURN: " ) ;
float real = Float.parseFloat( br.readLine( ) ) ; /* Notar que podemos usar
directamente el método readLine( ) [ llamado desde el objeto br ]
como argumento del método parseFloat de la clase Float, reduciendo todo a una
sola instrucción.*/
// Muestre en consola el número ingresado, concatenado con un mensaje:
System.out.println( "Usted ha digitado el numero real " + real ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica10
Informática I. Versión 1.0 Agosto de 2004
Salida:
54
Universidad Autónoma de Occidente
// Ejemplo 11 Esta aplicación Java muestra cómo ingresar números reales
// desde el teclado utilizando las clases Double y Float
import java.io.* ;
// importa el paquete de entrada - salida básica.
class EntradaBasica11 {
public static void main( String args[ ] ) throws IOException {
/* La línea subrayada habilita la entrada de datos desde el teclado.
Una vez más, el objetivo principal es crear un objeto, br, que nos permita invocar
el método readLine( ) de la clase BufferedReader. */
// Usted debe memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite el primer numero real y pulse RETURN: " ) ;
// Crea un objeto, x, de la clase Double:
Double x = new Double( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Double
double real1 = x.doubleValue( ) ;
System.out.print( "Digite el segundo numero real y pulse RETURN: " ) ;
// Crea un objeto, y, de la clase Float:
Float y = new Float( br.readLine( ) ) ; // la cadena String, retornada
// por el método readLine( ) de la clase BufferedReader, se envía al constructor
// de la clase Float
float real2 = y.floatValue( ) ;
// Muestre en consola los números ingresados:
System.out.println( "Primer numero real: " + real1 ) ;
System.out.println( "Segundo numero real: " + real2 ) ;
System.exit( 0 ) ;
}
}
// Salga de la Aplicación
// Fin del método main( )
// Fin de la clase EntradaBasica11
Informática I. Versión 1.0 Agosto de 2004
Salida:
55
Universidad Autónoma de Occidente
3.8 Más información sobre Java
Java surgió en 1991 cuando un grupo de ingenieros de Sun Microsystems trataron de diseñar un
nuevo lenguaje de programación destinado a electrodomésticos. La reducida potencia de cálculo y
memoria de los electrodomésticos llevó a desarrollar un lenguaje sencillo capaz de generar código de
tamaño muy reducido.
Debido a la existencia de distintos tipos de CPUs y a los continuos cambios, era importante
conseguir una herramienta independiente del tipo de CPU utilizada. Desarrollaron un código “neutro”
que no dependía del tipo de electrodoméstico, el cual se ejecutaba sobre una “máquina hipotética o
virtual” denominada Java Virtual Machine (JVM). Era la JVM quien interpretaba el código neutro
convirtiéndolo a código particular de la CPU utilizada. Esto permitía lo que luego se ha convertido en
el principal lema del lenguaje: “Write Once, Run Everywhere”. A pesar de los esfuerzos realizados
por sus creadores, ninguna empresa de electrodomésticos se interesó por el nuevo lenguaje.
Como lenguaje de programación para computadores, Java se introdujo a finales de 1995. La
clave fue la incorporación de un intérprete Java en la versión 2.0 del programa Netscape Navigator,
produciendo una verdadera revolución en Internet. Java 1.1 apareció a principios de 1997, mejorando
sustancialmente la primera versión del lenguaje. Java 1.2, más tarde rebautizado como Java 2, nació
a finales de 1998. Aunque hoy en día (2004) existe la versión 1.5 de Java, aún se le sigue llamando
Java 2.
Al programar en Java no se parte de cero. Cualquier aplicación que se desarrolle “cuelga” (o se
apoya, según como se quiera ver) en un gran número de clases preexistentes. Algunas de ellas las ha
podido hacer el propio usuario, otras pueden ser comerciales, pero siempre hay un número muy
importante de clases que forman parte del propio lenguaje (el API o Application Programming
Interface de Java). Java incorpora en el propio lenguaje muchos aspectos que en cualquier otro
lenguaje son ex tensiones propiedad de empresas de software o fabricantes de computadores (threads,
ejecución remota, componentes, seguridad, acceso a bases de datos, etc.). Por eso muchos expertos
opinan que Java es el lenguaje ideal para aprender la informática moderna, porque incorpora todos
estos conceptos de un modo estándar, mucho más sencillo y claro que con las citadas extensiones de
otros lenguajes. Esto es consecuencia de haber sido diseñado más recientemente y por un único
equipo.
El principal objetivo del lenguaje Java es llegar a ser el “nexo universal” que conecte a los
usuarios con la información, esté ésta situada en el computador local, en un servidor de Web, en una
base de datos o en cualquier otro lugar.
Java es un lenguaje muy completo. En cierta forma casi todo depende de casi todo. Por ello,
conviene aprenderlo de modo iterativo: primero una visión muy general, que se va refinando en
Informática I. Versión 1.0 Agosto de 2004
56
Universidad Autónoma de Occidente
sucesivas iteraciones. Una forma de hacerlo es empezar con un ejemplo completo en el que ya
aparecen algunas de las características más importantes.
La compañía Sun describe el lenguaje Java como “simple, orientado a objetos, distribuido,
interpretado, robusto, seguro, de arquitectura neutra, portable, de altas prestaciones, multitarea y
dinámico”. Además de una serie de halagos por parte de Sun hacia su propia criatura, el hecho es
que todo ello describe bastante bien el lenguaje Java, aunque en algunas de esas características el
lenguaje sea todavía bastante mejorable. Algunas de las anteriores ideas se irán explicando a lo largo
de este manual.
3.8.1 QUÉ ES JAVA 2
Java 2 (antes llamado Java 1.2 o JDK 1.2) se le llama tambien a las últimas versiones (Java 1.3,
Java 1.4 y Java 1.5) del lenguaje de programación Java.
Los programas desarrollados en Java presentan diversas ventajas frente a los desarrollados en
otros lenguajes como C/C++. La ejecución de programas en Java tiene muchas posibilidades:
ejecución como aplicación independiente (Stand-alone Application), ejecución como applet, ejecución
como servlet, etc. Un applet es una aplicación especial que se ejecuta dentro de un navegador o
browser (por ejemplo Netscape Navigator o Internet Explorer) al cargar una página HTML desde un
servidor Web. El applet se descarga desde el servidor y no requiere instalación en el computador
donde se encuentra el browser. Un servlet es una aplicación sin interface gráfica que se ejecuta en un
servidor de Internet. La ejecución como aplicación independiente es análoga a los programas
desarrollados con otros lenguajes.
Además de incorporar la ejecución como Applet, Java permite fácilmente el desarrollo tanto de
arquitecturas cliente-servidor como de aplicaciones distribuidas, consistentes en crear aplicaciones
capaces de conectarse a otros computadores y ejecutar tareas en varios computadores
simultáneamente, repartiendo por lo tanto el trabajo. Aunque también otros lenguajes de
programación permiten crear aplicaciones de este tipo, Java incorpora en su propio API estas
funcionalidades.
3.8.2 EL ENTORNO DE DESARROLLO DE JAVA
Existen distintos programas comerciales que permiten desarrollar código Java. La compañía Sun,
creadora de Java, distribuye gratuitamente el Java(tm) Development Kit (JDK). Se trata de un
conjunto de programas y librerías que permiten desarrollar, compilar y ejecutar programas en Java.
Incorpora además la posibilidad de ejecutar parcialmente el programa, deteniendo la ejecución en el
punto deseado y estudiando en cada momento el valor de cada una de las variables (con el
denominado Debugger). Cualquier programador con un mínimo de experiencia sabe que una parte
muy importante (muchas veces la mayor parte) del tiempo destinado a la elaboración de un programa
se destina a la detección y corrección de errores. Existe también una versión reducida del JDK,
denominada JRE (Java Runtime Environment) destinada únicamente a ejecutar código Java (no
permite compilar).
Los IDEs (Integrated Development Environment), tal y como su nombre indica, son entornos de
desarrollo integrados. En un mismo programa es posible escribir el código Java, compilarlo y
ejecutarlo sin tener que cambiar de aplicación. Algunos incluyen una herramienta para realizar Debug
gráficamente, frente a la versión que incorpora el JDK basada en la utilización de una consola
(denominada habitualmente ventana de comandos de MS-DOS, en Windows NT/95/98) bastante
difícil y pesada de utilizar. Estos entornos integrados permiten desarrollar las aplicaciones de forma
mucho más rápida, incorporando en muchos casos librerías con componentes ya desarrollados, los
Informática I. Versión 1.0 Agosto de 2004
57
Universidad Autónoma de Occidente
cuales se incorporan al proyecto o programa. Como inconvenientes se pueden señalar algunos fallos
de compatibilidad entre plataformas, y archivos resultantes de mayor tamaño que los basados en
clases estándar.
3.8.3 El compilador de Java
Se trata de una de las herramientas de desarrollo incluidas en el JDK. Realiza un análisis de sintaxis
del código escrito en los archivos fuente de Java (con extensión *.java). Si no encuentra errores en el
código genera los archivos compilados (con ex tensión *.class). En otro caso muestra la línea o líneas
erróneas. En el JDK de Sun dicho compilador se llama javac.exe. Tiene numerosas opciones, algunas
de las cuales varían de una versión a otra. Se aconseja consultar la documentación de la versión del
JDK utilizada para obtener una información detallada de las distintas posibilidades.
3.8.4 La Java Virtual Machine (JVM)
Tal y como se ha comentado al comienzo del capítulo, la existencia de distintos tipos de procesadores
y computadores llevó a los ingenieros de Sun a la conclusión de que era muy importante conseguir un
software que no dependiera del tipo de procesador utilizado. Se planteó la necesidad de conseguir un
código capaz de ejecutarse en cualquier tipo de máquina. Una vez compilado no debería ser necesaria
ninguna modificación por el hecho de cambiar de procesador o de ejecutarlo en otra máquina. La
clave consistió en desarrollar un código “neutro” el cual estuviera preparado para ser ejecutado sobre
una “máquina hipotética o virtual”, denominada Java Virtual Machine (JVM). Es esta JVM quien
interpreta este código neutro convirtiéndolo a código particular de la CPU utilizada. Se evita tener que
realizar un programa diferente para cada CPU o plataforma.
La JVM es el intérprete de Java. Ejecuta los “bytecodes” (archivos compilados con extensión
*.class) creados por el compilador de Java (javac.exe). Tiene numerosas opciones entre las que
destaca la posibilidad de utilizar el denominado JIT (Just-In-Time Compiler), que puede mejorar entre
10 y 20 veces la velocidad de ejecución de un programa.
3.8.5 Las variables PATH y CLASSPATH
El desarrollo y ejecución de aplicaciones en Java exige que las herramientas para compilar
(javac.exe) y ejecutar (java.exe) se encuentren accesibles. El computador, desde una ventana de
comandos de MS-DOS, sólo es capaz de ejecutar los programas que se encuentran en los directorios
indicados en la variable PATH del computador (o en el directorio activo). Si se desea compilar o
ejecutar código en Java, el directorio donde se encuentran estos programas (java.exe y javac.exe)
deberá encontrarse en el PATH. Tecleando PATH en una ventana de comandos de MS-DOS se
muestran los nombres de directorios incluidos en dicha variable de entorno.
Java utiliza además una nueva variable de entorno denominada CLASSPATH, la cual
determina dónde buscar tanto las clases o librerías de Java (el API de Java) como otras clases de
usuario. A partir de la versión 1.1.4 del JDK no es necesario indicar esta variable, salvo que se desee
añadir conjuntos de clases de usuario que no vengan con dicho JDK. La variable CLASSPATH
puede incluir la ruta de directorios o archivos *.zip o *.jar en los que se encuentren los archivos
*.class. En el caso de los archivos *.zip hay que observar que los archivos en él incluidos no deben
estar comprimidos. En el caso de archivos *.jar existe una herramienta (jar.exe), incorporada en el
JDK, que permite generar estos archivos a partir de los archivos compilados *.class. Los archivos
*.jar son archivos comprimidos y por lo tanto ocupan menos espacio que los archivos *.class por
separado o que el archivo *.zip equivalente.
Una forma general de indicar estas dos variables es crear un archivo batch de MS-DOS (*.bat)
donde se indiquen los valores de dichas variables. Cada vez que se abra una ventana de MS-DOS será
Informática I. Versión 1.0 Agosto de 2004
58
Universidad Autónoma de Occidente
necesario ejecutar este archivo *.bat para asignar adecuadamente estos valores. Un posible archivo
llamado jdk117.bat, podría ser como sigue:
set JAVAPATH=C:\j2sdk1.4.1_01
set PATH=.;%JAVAPATH%\bin;%PATH%
set CLASSPATH=.\;%JAVAPATH%\lib\classes.zip;%CLASSPATH%
lo cual sería válido en el caso de que el JDK estuviera situado en el directorio C:\jdk1.1.7.
Si no se desea tener que ejecutar este archivo cada vez que se abre una consola de MS-DOS es
necesario indicar estos cambios de forma “permanente”. La forma de hacerlo difiere entre Windows
95/98 y Windows NT. En Windows 95/98 es necesario modificar el archivo Autoexec.bat situado
en C:\, añadiendo las líneas antes mencionadas. Una vez rearrancado el computador estarán presentes
en cualquier consola de MS-DOS que se cree. La modificación al archivo Autoexec.bat enWindows
95/98 será la siguiente:
set JAVAPATH=C:\ j2sdk1.4.1_01
set PATH=.;%JAVAPATH%\bin;%PATH%
set CLASSPATH=
donde en la tercera línea debe incluir la ruta de los archivos donde están las clases de Java. En el caso
de utilizar Windows NT se añadirá la variable PATH en el cuadro de diálogo que se abre con Start > Settings -> Control Panel -> System -> Environment -> User Variables for NombreUsuario.
También es posible utilizar la opción –classpath en el momento de llamar al compilador
javac.exe o al intérprete java.exe. En este caso los archivos *.jar deben ponerse con el nombre
completo en el CLASSPATH: no basta poner el PATH o directorio en el que se encuentra. Por
ejemplo, si se desea compilar y ejecutar el archivo ContieneMain.java, y éste necesitara la librería de
clases G:\MyProject\OtherClasses.jar, además de las incluidas en el CLASSPATH, la forma de
compilar y ejecutar sería:
javac -classpath .\;G:\MyProject\OtherClasses.jar ContieneMain.java
java -classpath .\;G:\MyProject\OtherClasses.jar ContieneMain
Se aconseja consultar la ayuda correspondiente a la versión que se esté utilizando, debido a que
ex isten pequeñas variaciones entre las distintas versiones del JDK.
Cuando un archivo filename.java se compila y en ese directorio existe ya un archivo
filename.class, se comparan las fechas de los dos archivos. Si el archivo filename.java es más
antiguo que el filename.class no se produce un nuevo archivo filename.class. Esto sólo es válido para
archivos *.class que se corresponden con una clase public.
3.8.6 NOMENCLATURA HABITUAL EN LA PROGRAMACIÓN EN JAVA
Los nombres de Java son sensibles a las letras mayúsculas y minúsculas. Así, las variables masa,
Masa y MASA son consideradas variables completamente diferentes. Las reglas del lenguaje respecto
a los nombres de variables son muy amplias y permiten mucha libertad al programador, pero es
habitual seguir ciertas normas que facilitan la lectura y el mantenimiento de los programas de
computador. Se recomienda seguir las siguientes instrucciones:
1. En Java es habitual utilizar nombres con minúsculas, con las excepciones que se indican en los
puntos siguientes.
Informática I. Versión 1.0 Agosto de 2004
59
Universidad Autónoma de Occidente
2. Cuando un nombre consta de varias palabras es habitual poner una a continuación de otra,
poniendo con mayúscula la primera letra de la palabra que sigue a otra (Ejemplos: elMayor(),
VentanaCerrable, RectanguloGrafico, addWindowListener()).
3. Los nombres de clases e interfaces comienzan siempre por mayúscula (Ejemplos: Geometria,
Rectangulo, Dibujable, Graphics, ArrayList, Iterator).
4. Los nombres de objetos, los nombres de métodos y variables miembro, y los nombres de las
variables locales de los métodos, comienzan siempre por minúscula (Ejemplos: main(),
dibujar(), numRectangulos, x, y, r).
5. Los nombres de las variables finales, es decir de las constantes, se definen siempre con mayúsculas
(Ejemplo: PI)
3.8.7 ESTRUCTURA GENERAL DE UN PROGRAMA JAVA
El anterior ejemplo presenta la estructura habitual de un programa realizado en cualquier lenguaje
orientado a objetos u OOP (Object Oriented Programming), y en particular en el lenguaje Java.
Aparece una clase que contiene el programa principal (aquel que contiene la función main()) y
algunas clases de usuario (las específicas de la aplicación que se está desarrollando) que son utilizadas
por el programa principal. Los archivos fuente tienen la extensión *.java, mientras que los archivos
compilados tienen la extensión *.class.
Un archivo fuente (*.java) puede contener más de una clase, pero sólo una puede ser public. El
nombre del archivo fuente debe coincidir con el de la clase public (con la ex tensión *.java). Si por
ejemplo en un archivo aparece la declaración (public class MiClase {...}) entonces el nombre del
archivo deberá ser MiClase.java. Es importante que coincidan mayúsculas y minúsculas ya que
MiClase.java y miclase.java serían clases diferentes para Java. Si la clase no es public, no es
necesario que su nombre coincida con el del archivo. Una clase puede ser public o package (default),
pero no private o protected. Estos conceptos se explican posteriormente.
De ordinario una aplicación está constituida por varios archivos *.class. Cada clase realiza unas
funciones particulares, permitiendo construir las aplicaciones con gran modularidad e independencia
entre clases. La aplicación se ejecuta por medio del nombre de la clase que contiene la función main()
(sin la extensión *.class). Las clases de Java se agrupan en packages, que son librerías de clases. Si
las clases no se definen como pertenecientes a un package, se utiliza un package por defecto (default)
que es el directorio activo. Los packages se estudian con más detenimiento en próximos capitulos.
Informática I. Versión 1.0 Agosto de 2004
60
Universidad Autónoma de Occidente
UNIDAD 4. TIPOS DE DATOS, VARIABLES Y OPERADORES.
4. PROGRAMACIÓN EN JAVA
En este capítulo se presentan las características generales de Java como lenguaje de programación
algorítmico. En este apartado Java es muy similar a C/C++, lenguajes en los que está inspirado.
4.1 VARIABLES
Una variable es un nombre que contiene un valor que puede cambiar a lo largo del programa. De
acuerdo con el tipo de información que contienen, en Java hay dos tipos principales de variables:
1. Variables de tipos primitivos. Están definidas mediante un valor único que puede ser entero,
de punto flotante, carácter o booleano. Java permite distinta precición y distintos rangos de
valores para estos tipos de variables (char, byte, short, int, long, float, double, boolean).
Ejemplos de variables de tipos primitivos podrían ser: 123, 3456754, 3.1415, 12e-09, 'A',
true, etc.
2. Variables referencia. Las variables referencia son referencias o nombres de una información
más compleja: arrays u objetos de una determinada clase.
Desde el punto de vista del papel o misión en el programa, las variables pueden ser:
1. Variables miembro de una clase: Se definen en una clase, fuera de cualquier método; pueden
ser tipos primitivos o referencias.
2. Variables locales: Se definen dentro de un método o más en general dentro de cualquier
bloque entre llaves {}. Se crean en el interior del bloque y se destruyen al finalizar dicho
bloque. Pueden ser también tipos primitivos o referencias.
4.1.1 Nombres de Variables
Los nombres de variables en Java se pueden crear con mucha libertad. Pueden ser cualquier conjunto
de caracteres numéricos y alfanuméricos, sin algunos caracteres especiales utilizados por Java como
operadores o separadores ( ,.+-*/ etc.).
Existe una serie de palabras reservadas las cuales tienen un significado especial para Java y por
lo tanto no se pueden utilizar como nombres de variables. Dichas palabras son:
abstract
char
double
for
int
package
static
throws
boolean
class
else
goto*
interface
private
super
transient
break
const*
extends
if
long
protected
switch
try
byte
continue
final
implements
native
public
synchronized
void
case
default
finally
import
new
return
this
volatile
catch
do
float
instanceof
null
short
throw
while
(*) son palabras reservadas, pero no se utilizan en la actual implementación del lenguaje Java.
Informática I. Versión 1.0 Agosto de 2004
61
Universidad Autónoma de Occidente
4.1.2
Tipos Primitivos de Variables
Se llaman tipos primitivos de variables de Java a aquellas variables sencillas que contienen los tipos
de información más habituales: valores boolean, caracteres y valores numéricos enteros o de punto
flotante.
Java dispone de ocho tipos primitivos de variables: un tipo para almacenar valores true y false
(boolean); un tipo para almacenar caracteres (char), y 6 tipos para guardar valores numéricos, cuatro
tipos para enteros (byte, short, int y long) y dos para valores reales de punto flotante (float y double).
Los rangos y la memoria que ocupa cada uno de estos tipos se muestran en la Tabla 4.1.
Tipo de variable
Descripción
Boolean
Char
Byte
Short
Int
Long
Float
1 byte. Valores true y false
2 bytes. Unicode. Comprende el código ASCII
1 byte. Valor entero entre -128 y 127
2 bytes. Valor entero entre -32768 y 32767
4 bytes. Valor entero entre -2.147.483.648 y 2.147.483.647
8 bytes. Valor entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807
4 bytes (entre 6 y 7 cifras decimales equivalentes). De -3.402823E38 a -1.401298E-45
y de 1.401298E-45 a 3.402823E38
8 bytes (unas 15 cifras decimales equivalentes). De -1.79769313486232E308 a
-4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308
Double
Tabla 4.1. Tipos primitivos de variables en Java.
Los tipos primitivos de Java tienen algunas características importantes que se resumen a
continuación:
1. El tipo boolean no es un valor numérico: sólo admite los valores true o false. El tipo boolean
no se identifica con el igual o distinto de cero, como en C/C++. El resultado de la ex presión
lógica que aparece como condición en un bucle o en una Decisión debe ser boolean.
2. El tipo char contiene caracteres en código UNICODE (que incluye el código ASCII), y
ocupan 16 bits por carácter. Comprende los caracteres de prácticamente todos los idiomas.
3. Los tipos byte, short, int y long son números enteros que pueden ser positivos o negativos,
con distintos valores máximos y mínimos. A diferencia de C/C++, en Java no hay enteros
unsigned.
4. Los tipos float y double son valores de punto flotante (números reales) con 6-7 y 15 cifras
decimales equivalentes, respectivamente.
5. Se utiliza la palabra void para indicar la ausencia de un tipo de variable determinado.
6. A diferencia de C/C++, los tipos de variables en Java están perfectamente definidos en todas
y cada una de las posibles plataformas. Por ejemplo, un int ocupa siempre la misma memoria
y tiene el mismo rango de valores, en cualquier tipo de computador.
7. Existen extensiones de Java 1.2 para aprovechar la arquitectura de los procesadores Intel, que
permiten realizar operaciones de punto flotente con una precisión extendida de 80 bits.
4.1.3 Cómo se definen e inicializan las variables
Una variable se define especificando el tipo y el nombre de dicha variable. Estas variables pueden
ser tanto de tipos primitivos como referencias a objetos de alguna clase perteneciente al API de Java
o generada por el usuario. Si no se especifica un valor en su declaración, las variables
Informática I. Versión 1.0 Agosto de 2004.
62
Universidad Autónoma de Occidente
primitivas se inicializan a cero (salvo boolean y char, que se inicializan a false y '\0').
Análogamente las variables de tipo referencia son inicializadas por defecto a un valor especial: null.
Es importante distinguir entre la referencia a un objeto y el objeto mismo. Una referencia es una
variable que indica dónde está guardado un objeto en la memoria del computador (a diferencia de
C/C++, Java no permite acceder al valor de la dirección, pues en este lenguaje se han eliminado los
punteros). Al declarar una referencia todavía no se encuentra “apuntando” a ningún objeto en
particular (salvo que se cree explícitamente un nuevo objeto en la declaración), y por eso se le asigna
el valor null. Si se desea que esta referencia apunte a un nuevo objeto es necesario crear el objeto
utilizando el operador new. Este operador reserva en la memoria del computador espacio para ese
objeto (variables y funciones). También es posible igualar la referencia declarada a otra referencia a
un objeto existente previamente.
Un tipo particular de referencias son los arrays o vectores, sean éstos de variables primitivas
(por ejemplo, un vector de enteros) o de objetos. En la declaración de una referencia de tipo array hay
que incluir los corchetes [ ]. En los siguientes ejemplos aparece cómo crear un vector de 10 números
enteros y cómo crear un vector de elementos MyClass. Java garantiza que los elementos del vector
son inicializados a null o a cero (según el tipo de dato) en caso de no indicar otro valor.
Ejemplos de declaración e inicialización de variables:
int x;
// Declaración de la variable primitiva x. Se inicializa a 0
inty=5;
//Declaración de la variable primitiva y. Se inicializa a 5
MyClass unaRef;
// Declaración de una referencia a un objeto MyClass.
// Se inicializa a null
unaRef = new MyClass();
// La referencia “apunta” al nuevo objeto creado
// Se ha utilizado el constructor por defecto
MyClass segundaRef = unaRef; // Declaración de una referencia a un objeto MyClass.
// Se inicializa al mismo valor que unaRef
int [ ] vector;
// Declaración de un array. Se inicializa a null
vector = new int[10];
// Vector de 10 enteros, inicializados a 0
double [ ] v = {1.0, 2.65, 3.1}; // Declaración e inicialización de un vector de 3
// elementos con los valores entre llaves
MyClass [ ] lista=new MyClass[5]; // Se crea un vector de 5 referencias a objetos
// Las 5 referencias son inicializadas a null
lista[0] = unaRef;
// Se asigna a lista[0] el mismo valor que unaRef
lista[1] = new MyClass();
// Se asigna a lista[1] la referencia al nuevo objeto
// El resto (lista[2]…lista[4] siguen con valor null
En el ejemplo mostrado las referencias unaRef, segundaRef y lista[0] actuarán sobre el mismo objeto.
Es equivalente utilizar cualquiera de las referencias ya que el objeto al que se refieren es el mismo.
4.1.4 Visibilidad y vida de las variables
Se entiende por visibilidad, ámbito o scope de una variable, la parte de la aplicación donde dicha
variable es accesible y por lo tanto puede ser utilizada en una expresión. En Java todas las variables
deben estar incluidas en una clase. En general las variables declaradas dentro de unas llaves {}, es
decir dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo las variables
declaradas al principio de una función existen mientras se ejecute la función; las variables declaradas
dentro de un bloque if no serán válidas al finalizar las sentencias correspondientes a dicho if y las
variables miembro de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de
cualquier método) son válidas mientras existe el objeto de la clase.
Informática I. Versión 1.0 Agosto de 2004.
63
Universidad Autónoma de Occidente
Las variables miembro de una clase declaradas como public son accesibles a través de una referencia
a un objeto de dicha clase utilizando el operador punto (.). Las variables miembro declaradas como
private no son accesibles directamente desde otras clases. Las funciones miembro de una clase tienen
acceso directo a todas las variables miembro de la clase sin necesidad de anteponer el nombre de un
objeto de la clase. Sin embargo las funciones miembro de una clase B derivada de otra A, tienen
acceso a todas las variables miembro de A declaradas como public o protected, pero no a las
declaradas como private. Una clase derivada sólo puede acceder directamente a las variables y
funciones miembro de su clase base declaradas como public o protected. Otra característica del
lenguaje es que es posible declarar una variable dentro de un bloque con el mismo nombre que una
variable miembro, pero no con el nombre de otra variable local que ya existiera. La variable declarada
dentro del bloque oculta a la variable miembro en ese bloque. Para acceder a la variable miembro
oculta será preciso utilizar el operador this, en la forma this.varname.
Uno de los aspectos más importantes en la programación orientada a objetos (OOP) es la forma en la
cual son creados y eliminados los objetos. En Java la forma de crear nuevos objetos es utilizando el
operador new. Cuando se utiliza el operador new, la variable de tipo referencia guarda la posición de
memoria donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta de por uántas
variables de tipo referencia es apuntado. La eliminación de los objetos la realiza el programa
denominado garbage collector, quien automáticamente libera o borra la memoria ocupada por un
objeto cuando no existe ninguna referencia apuntando a ese objeto. Lo anterior significa que aunque
una variable de tipo referencia deje de existir, el objeto al cual apunta no es eliminado si hay otras
referencias apuntando a ese mismo objeto.
4.1.5 Casos especiales: Clases BigInteger y BigDecimal
Java 1.1 incorporó dos nuevas clases destinadas a operaciones aritméticas que requieran gran
precisión: BigInteger y BigDecimal. La forma de operar con objetos de estas clases difiere de las
operaciones con variables primitivas. En este caso hay que realizar las operaciones utilizando métodos
propios de estas clases (add() para la suma, subtract() para la resta, divide() para la división, etc.). Se
puede consultar la ayuda sobre el package java.math, donde aparecen ambas clases con todos sus
métodos.
Los objetos de tipo BigInteger son capaces de almacenar cualquier número entero sin perder
información durante las operaciones. Análogamente los objetos de tipo BigDecimal permiten trabajar
con el número de decimales deseado.
4.2 OPERADORES DE JAVA
Java es un lenguaje rico en operadores, que son casi idénticos a los de C/C++. Estos operadores se
describen brevemente en los apartados siguientes.
4.2.1 Operadores aritméticos
Son operadores binarios (requieren siempre dos operandos) que realizan las operaciones aritméticas
habituales: suma (+), resta (-), multiplicación (*), división (/) y resto de la división (%).
Informática I. Versión 1.0 Agosto de 2004.
64
Universidad Autónoma de Occidente
4.2.2 Operadores de asignación
Los operadores de asignación permiten asignar
un valor a una variable. El operador de
asignación por excelencia es el operador igual
(=). La forma general de las sentencias de
asignación con este operador es:
variable = expression;
Operador Utilización Expresión equivalente
+=
-=
*=
/=
%=
op1 + = op2
op1 -= op2
op1 *= op2
op1 /= op2
op1 %= op2
op1 = op1 + op2
op1 = op1 - op2
op1 = op1 * op2
op1 = op1 / op2
op1 = op1 % op2
Tabla 4.2. Otros operadores de asignación.
Java dispone de otros operadores de
asignación. Se trata de versiones abreviadas del
operador (=) que realizan operaciones “acumulativas” sobre una variable. La Tabla 4.2 muestra estos
operadores y su equivalencia con el uso del operador igual (=).
4.2.3 Operadores unarios
Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el signo de una variable,
constante o expresión numérica. Su uso en Java es el estándar de estos operadores.
4.2.4 Operador instanceof
El operador instanceof permite saber si un objeto pertenece o no a una determinada clase. Es un
operador binario cuya forma general es, objectName instanceof ClassName y que devuelve true o
false según el objeto pertenezca o no a la clase.
4.2.5 Operador condicional ?:
Este operador, tomado de C/C++, permite realizar decisiones condicionales sencillas. Su forma
general es la siguiente:
booleanExpression ? res1 : res2
donde se evalúa booleanExpression y se devuelve res1 si el resultado es true y res2 si el resultado es
false. Es el único operador ternario (tres argumentos) de Java. Como todo operador que devuelve un
valor puede ser utilizado en una expresión. Por ejemplo las sentencias:
x=1 ; y=10; z = (x<y)?x+3:y+8;
asignarían a z el valor 4, es decir x+3.
4.2.6 Operadores incrementales
Java dispone del operador incremento (++) y decremento (--). El operador (++) incrementa en una
unidad la variable a la que se aplica, mientras que (--) la reduce en una unidad. Estos operadores se
pueden utilizar de dos formas:
1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se incrementa la variable y
luego se utiliza (ya incrementada) en la expresión en la que aparece.
2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se utiliza la variable en la
expresión (con el valor anterior) y luego se incrementa.
En muchas ocasiones estos operadores se utilizan para incrementar una variable fuera de una
expresión. En este caso ambos operadores son equivalente. Si se utilizan en una expresión más
Informática I. Versión 1.0 Agosto de 2004.
65
Universidad Autónoma de Occidente
complicada, el resultado de utilizar estos operadores en una u otra de sus formas será diferente. La
actualización de contadores en bucles for es una de las aplicaciones más frecuentes de estos
operadores.
4.2.7 Operadores relacionales
Los operadores relacionales sirven para
realizar comparaciones de igualdad,
desigualdad y relación de menor o mayor.
El resultado de estos operadores es
siempre un valor boolean (true o false)
según se cumpla o no la relación
considerada. La Tabla 4.3 muestra los
operadores relacionales de Java.
Operador Utilización El resultado es true
>
op1 > op2
si op1 es mayor que op2
>=
op1 >= op2 si op1 es mayor o igual que op2
<
op1 < op2 si op1 es menor que op2
<=
op1 <= op2 si op1 es menor o igual que op2
==
op1 == op2 si op1 y op2 son iguales
!=
op1 != op2 si op1 y op2 son diferentes
Tabla 4.3. Operadores relacionales.
Estos operadores se utilizan con mucha frecuencia en las decisiones y en los bucles, que se verán
en próximos apartados de este capítulo.
4.2.8 Operadores lógicos
Los operadores lógicos se utilizan para construir expresiones lógicas, combinando valores lógicos
(true y/o false) o los resultados de los operadores relacionales. La Tabla 4.4 muestra los operadores
lógicos de Java. Debe notarse que en ciertos casos el segundo operando no se evalúa porque ya no
es necesario (si ambos tienen que ser true y el primero es false, ya se sabe que la condición de que
ambos sean true no se va a cumplir). Esto puede traer resultados no deseados y por eso se han añadido
los operadores (&) y (|) que garantizan que los dos operandos se evalúan siempre.
Operador Nombre
Utilización Resultado
&&
||
AND
OR
op1 && op2 true si op1 y op2 son true. Si op1 es false ya no se evalúa op2
!
&
|
negación
AND
OR
op1 || op2
! op
op1 & op2
op1 | op2
true si op1 u op2 son true. Si op1 es true ya no se evalúa op2
true si op es false y false si op es true
true si op1 y op2 son true. Siempre se evalúa op2
true si op1 u op2 son true. Siempre se evalúa op2
Tabla 4.4. Operadores lógicos.
4.2.9 Operador de concatenación de cadenas de caracteres (+)
El operador más (+) se utiliza también para concatenar cadenas de caracteres. Por ejemplo, para
escribir una cantidad con un rótulo y unas unidades puede utilizarse la sentencia:
System.out.println("El total asciendea"+result + " unidades");
donde el operador de concatenación se utiliza dos veces para construir la cadena de caracteres que se
desea imprimir por medio del método println(). La variable numérica result es convertida
automáticamente por Java en cadena de caracteres para poderla concatenar. En otras ocasiones se
deberá llamar explícitamente a un método para que realice esta conversión.
Informática I. Versión 1.0 Agosto de 2004.
66
Universidad Autónoma de Occidente
4.2.10 Operadores que actúan a nivel de bits
Java dispone también de un conjunto de operadores que actúan a nivel de bits. Las Operaciones de
bits se utilizan con frecuencia para definir señales o flags, esto es, variables de tipo entero en las
quecada uno de sus bits indican si una opción está activada o no. La Tabla 4.5 muestra los operadores
de Java que actúan a nivel de bits.
Operador Utilización
>>
op1 >> op2
<<
op1 << op2
>>>
op1 >>> op2
&
op1 & op2
|
op1 | op2
^
op1 ^ op2
~
~op2
Resultado
Desplaza los bits de op1 a la derecha una distancia op2
Desplaza los bits de op1 a la izquierda una distancia op2
Desplaza los bits de op1 a la derecha una distancia op2 (positiva)
Operador AND a nivel de bits
Operador OR a nivel de bits
Operador XOR a nivel de bits (1 si sólo uno de los operandos es 1)
Operador complemento (invierte el valor de cada bit)
Tabla 4.5. Operadores a nivel de bits.
En binario, las potencias de dos se representan con un único bit activado. Por ejemplo, los números (1,
2, 4, 8, 16, 32, 64, 128) se representan respectivamente de modo binario en la forma (00000001,
00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000), utilizando sólo 8 bits.
La suma de estos números permite construir una variable flags con los bits activados que se deseen.
Por ejemplo, para construir una variable flags que sea 00010010 bastaría hacer flags=2+16. Para
saber si el segundo bit por la derecha está o no activado bastaría utilizar la sentencia,
if (flags&2==2){...}
La Tabla 4.6 muestra los operadores de asignación a nivel de bits.
Operador
Utilización
Equivalente a
&=
|=
^=
<<=
>>=
>>>=
op1 &= op2
op1 |= op2
op1 ^= op2
op1 <<= op2
op1 >>= op2
op1 >>>= op2
op1 = op1 & op2
op1 = op1 | op2
op1 = op1 ^ op2
op1 = op1 << op2
op1 = op1 >> op2
op1 = op1 >>> op2
Tabla 4.6. Operadores de asignación a nivel de bits.
4.2.11 Precedencia de operadores
El orden en que se realizan las operaciones es fundamental para determinar el resultado de una
expresión. Por ejemplo, el resultado de x/y*z depende de qué operación (la división o el producto) se
realice primero. La siguiente lista muestra el orden en que se ejecutan los distintos operadores en un
sentencia, de mayor a menor precedencia:
postfix operators
unary operators
creation or cast
multiplicative
additive
shift
Informática I. Versión 1.0 Agosto de 2004.
[ ] . (params) expr++ expr-++expr --expr +expr -expr ~ !
new (type)expr
*/%
+<< >> >>>
67
Universidad Autónoma de Occidente
relational
equality
bitwise AND
bitwise exclusive OR
bitwise inclusive OR
logical AND
logical OR
conditional
assignment
< > <= >= instanceof
== !=
&
^
|
&&
||
?:
= += -= *= /= %= &= ^= |= <<= >>= >>>=
Java, todos los operadores binarios, excepto los operadores de asignación, se evalúan de
izquierda a derecha. Los operadores de asignación se evalúan de derecha a izquierda, lo que
En
significa que el valor de la derecha se copia sobre la variable de la izquierda.
Informática I. Versión 1.0 Agosto de 2004.
68
Universidad Autónoma de Occidente
UNIDAD 5. ALGORITMOS
Este capítulo trata de ser una introducción a la metodología y tecnología de la programación, con el
objetivo de proporcionar al lector los procedimientos y técnicas para el desarrollo de programas.
Por obvio que parezca, no hay que olvidar que los programas se escriben con el ánimo de resolver
problemas con ayuda de las computadoras y que la primera medida a considerar es el análisis del
problema en cuestión y la obtención, en su caso, de un algoritmo adecuado. Por tanto, empezaremos
nuestra exposición hasta llegar a los métodos y etapas a seguir para obtener una aplicación
informática.
Si bien los conceptos que aquí se introducen son fundamentales para la realización de programas,
este capítulo no debe leerse como si se tratara de un manual de programación, sino como una
fundamentación de lo que llamamos programación estructurada, más allá de la sintaxis y de la
semántica de un lenguaje de programación concreto.
No obstante lo anterior, es sano en este momento informarle que se le irà familiarizando con un
lenguaje especìfico: el lenguaje de programación Java. O sea, irá conociendo su sintaxis. Esto debe
ser así, pues una de las cosas que más estimula a un estudiante que se inicia en la informática es ver
cómo sus programas funcionan al ser ejecutados en una computadora y, para lograrlo, se necesita de
un lenguaje de programación.
Concepto de Algoritmo
Definición de algoritmo. Etimología del término algoritmo
En general, Un algoritmo es una secuencia de instrucciones o pasos que es llevada a cabo de forma
mecánica y sistemática por un actor que se desenvuelve en un ambiente o entorno dado, para resolver
un problema determinado en un tiempo finito.
Esa es una definición válida de algoritmo, otra posible definición es la siguiente:
Un algoritmo es un conjunto de instrucciones combinadas de forma adecuada para resolver un
determinado problema en una cantidad finita de tiempo. Cada instrucción es una indicación sencilla y
no ambigua.
Despues de los siguientes ejemplos, el alumno debería tener bastante claro qué es un algoritmo, en
qué consiste y dar ejemplos de algoritmos; ahora es probable que se esté preguntando de dónde
procede el mismo término, “ALGORITMO”, ¿por qué denominamos “algoritmos” a los algoritmos y
no “recetas” o “combinaciones de indicaciones sencillas y no ambiguas...”?
El término proviene de Mahommed ibn Musa al-Khowârizmî (Mahommed, hijo de Musa, natural de
Kharizm), matemático persa del siglo IX; las matemáticas le deben la introducción del sistema de
numeración actual y del álgebra.
En su libro De numero indiorum (Sobre los números hindúes) proporciona las reglas para realizar las
operaciones aritméticas (con los nuevos números, por supuesto), dichas reglas se denominaron “reglas
de al-Khowârizmî” y, por deformación “algoritmos”, haciéndose extensivo el término a cualquier
conjunto de reglas para resolver un problema determinado.
Resolución de Problemas y el Uso del Computador
Informática I. Versión 1.0 Agosto de 2004.
69
Universidad Autónoma de Occidente
Antes de entrar en la codificación para la resolución de un problema por técnicas informáticas,
hemos de contar con una idea bastante precisa de cómo podemos llegar a esta solución.
Resolución de
un problema
Diseño del
algoritmo
Análisis del
problema
Programación
del algoritmo
Fig. 5.1. La resolución de un problema en Informática
El matemático G. Poyla propuso, a finales de 1940, una metodología general para la resolución de
problemas matemáticos, que ha sido adaptada para el caso en que se cuente con un computador como
recurso. Esta metodología, de forma muy esquematizada, se puede dividir en tres fases (Ver Figura
3.1):
1. Análisis del problema
2. Diseño del algoritmo
3. Programación del algoritmo
Análisis del problema
El objetivo del análisis del problema, es ayudar al programador a llegar a una cierta comprensión de
la naturaleza del mismo. Este análisis supone, en particular, la superación de una serie de pasos (Ver
Figura 3.2):
-
Definir el problema con total precisión.
Especificar los datos de partida necesarios para la resolución del mismo (especificaciones de
entrada).
Especificar la información que debe proporcionarse al resolverse (especificaciones de salida).
Análisis del
problema
Definición
del problema
Especificiones
de entrada
Especificacion
es de salida
Fig. 5.2. Análisis del problema
Ejemplo :
Elaborar el análisis general que responda a la pregunta: ¿Qué debo hacer para ver la película XYZ?.
1.
2.
3.
4.
Ir al cine donde proyectan MatriX
Comprar una entrada.
Ver la película.
Regresar a casa.
Ejemplo :
Elaborar el análisis para obtener el área y la longitud de una circunferencia.
1. Utilizar las fórmulas del área y la circunferencia en función del radio.
2. Las entradas de datos se reducen al dato correspondiente al radio del círculo.
3. Las salidas serán los datos solicitados: área y circunferencia.
Informática I. Versión 1.0 Agosto de 2004.
70
Universidad Autónoma de Occidente
Diseño del Algoritmo
Seamos optimistas y pensemos que vamos a tener la capacidad de tener ideas, propias o adquiridas,
para desarrollar algoritmos que nos permitan actuar ante los problemas que se nos planteen.
Para diseñar algoritmos hay que tener presente los requisitos ó caracteríticas siguientes:
• Preciso: El algoritmo debe indicar con mucha claridad el orden de realización de cada
paso.
• Definido: Si se sigue un algoritmo dos veces , se debe obtener el mismo resultado cada
vez, es decir, estar definido sin ambigüedad.
• Finito: Si se sigue un algoritmo, se debe terminar en algún momento; o sea, debe tener un
número finito de pasos.
Ejemplo:
Instrucciones para subir una escalera
[...] Las escaleras se suben de frente, pues hacia atrás o de costado resultan particularmente
incómodas. La actitud natural consiste en mantenerse de pie, los brazos colgando sin esfuerzo, la
cabeza erguida aunque no tanto tal que los ojos puedan ver los peldaños inmediatamente superiores al
que se pisa, y respirando lenta y regularmente. Para subir una escalera se comienza por levantar esa
parte del cuerpo situada a la derecha abajo, envuelta casi siempre en cuero o gamuza, y que salvo
excepciones cabe exactamente en el escalón. Puesta en el primer peldaño dicha parte, que para
abreviar llamaremos pie, se recoge la parte equivalente de la izquierda (también llamada pie, pero que
no ha de confundirse con el pie antes citado), y llevándola a la altura del pie, se le hace seguir hasta
colocarla en el segundo peldaño, con lo cual en éste descansará el pie, y en el primero descansará el
pie. (Los primeros peldaños son siempre los más difíciles, hasta adquirir la coordinación necesaria. La
coincidencia de nombre entre el pie y el pie hace difícil la explicación. Cuídese especialmente de no
levantar al mismo tiempo el pie y el pie).
Llegando en esta forma al segundo peldaño, basta repetir alternadamente los movimientos hasta
encontrarse con el final de la escalera. Se sale de ella fácilmente, con un ligero golpe de talón que la
fija en su sitio, del que no se moverá hasta el momento del descenso.
Ejemplo:
Elaborar Tortilla de patatas a la española (6 personas)
Ingredientes:
- 2 vasos (de los de agua) de aceite (1/2 litro)
- Sal
- 8 huevos
- 1 kg de patatas
Se pelan las patatas, se lavan y se secan con un paño; se parten en dos a lo largo y después se cortan
en láminas finitas. Se pone el aceite a calentar en la sartén y se fríen las patatas, moviéndolas de vez
en cuando y echándoles un poco de sal.
Una vez fritas (más o menos doradas, según gusten), se separan y se ponen a escurrir en un colador
grande. Se quita el aceite sobrante de la sartén.
Aparte se baten los huevos con tenedor y muy fuerte; se pone un poco de sal; en el mismo plato de los
huevos se echan las patatas y se mueven con un tenedor.
En una sartén grande (o en dos pequeñas) se ponen 3 cucharadas soperas de aceite para que sólo cubra
el fondo. Cuando está caliente se vierte la mezcla de huevos y patatas. Se mueve la sartén por el
mango para que no se pegue la tortilla. Cuando se vea que está bien despegada y dorada (esto depende
Informática I. Versión 1.0 Agosto de 2004.
71
Universidad Autónoma de Occidente
del gusto de cada cual), se pone una tapadera encima, se vuelca la sartén y se escurre suavemente la
tortilla otra vez en la sartén. Se vuelve a mover por el mango y cuando esté cuajada (a gusto) se pasa a
una fuente redonda y se sirve.
Ejemplo:
Algoritmo “infantil”: Multiplicación de números enteros
Para obtener el producto de dos números enteros utilizando lápiz y papel se debe escribir el primer
factor (multiplicando) y, justo debajo y alineado a la derecha, el segundo factor (multiplicador).
Se recorren todas las cifras del multiplicador de derecha a izquierda y se operan con cada una de las
cifras el multiplicando, también de derecha a izquierda, escribiendo los resultados intermedios en
líneas separadas; cada línea estará desplazada una posición a la izquierda respecto a la línea
inmediatamente superior.
Una vez se han obtenido todos los resultados intermedios se suman columna a columna
obteniéndose el resultado final.
Numerando cada uno de los pasos a seguir en cada uno de los algoritmos, formalizamos un poco
nuestro lenguaje cotidiano para escribir algoritmos, veamos:
Ejemplo:
Cambiar la rueda pinchada de un automóvil teniendo un gato mecánico en buen estado, una rueda de
reemplazo y una llave inglesa.
Los pasos del algoritmo son:
1. Inicio
2. Aflojar los tornillos de la rueda pinchada con la llave inglesa.
3. Ubicar el gato mecánico en su sitio.
4. Levantar el gato hasta que la rueda pinchada pueda girar libremente.
5. Quitar los tornillos y la rueda pinchada.
6. Poner rueda de repuesto y los tornillos.
7. Bajar el gato hasta que se pueda liberar.
8. Sacar el gato de su sitio.
9. Apretar los tornillos con la llave inglesa.
10. Fin.
Podríamos modificar este algoritmo, bien sea escribiendo más líneas de detalle ó uniendo algunos
pasos, y aún así funcionaría para resolver nuestro problema. Esto quiere decir que podemos tener
algoritmos diferentes, con diferente diseño, que resuelven el mismo problema. ¿Cuál de ellos es más
eficiente, hablando desde el punto de vista computacional? Ese es tema de otro curso, por el
momento nos debemos concentrar en cual algoritmo es más claro, cual es más fácil de entender.
Ejemplo:
Un cliente hace un pedido a una fábrica. La fábrica examina en su banco de datos la ficha del cliente,
si el cliente es solvente entonces la empresa acepta el pedido; en caso contrario lo rechaza. Elabore el
algoritmo correspondiente.
Los pasos del algoritmo son:
1. Inicio.
2. Leer el pedido.
3. Examinar la ficha del cliente.
4. Si el cliente es solvente, aceptar pedido; en caso contrario, rechazarlo.
5. Fin.
Informática I. Versión 1.0 Agosto de 2004.
72
Universidad Autónoma de Occidente
Ejemplo:
Averiguar si un número entero positivo es primo o no, dado que conocemos la definición de número
primo: un número entero positivo, N, es primo si sólo puede dividirse por sí mismo y por la unidad.
Un método que nos puede dar la solución sería dividir sucesivamente el número por 2, 3, 4...N, y,
según el resultado, podríamos resolver el problema. Un diseño del mismo sería:
1. Inicio.
2. Poner X igual a 2 (X = 2, donde X es una variable que representa a los posibles divisores
de N).
3. Dividir N por X (N/X).
4. Si el resultado de N/X es entero, entonces N no es primo (pues esto indicaría que N es
divisible entre X) y saltar al punto 9; en caso contrario continuar el proceso en el siguiente
punto, 5.
5. Incrementar X en una unidad (X = X + 1)
6. Si X es menor que N saltar al punto 3, en caso contrario continuar el proceso en el siguiente
punto, 7.
7. Declarar que N es primo;
8. Saltar al Fin (punto 10)
9. Declarar que N no es primo
10. Fin
Como parte del diseño de un algoritmo está la selección de aquél que sea razonablemente aceptable,
entre todos los muchos posibles que resuelven el mismo problema (el ejemplo que acabamos de dar
es claramente mejorable, pues si N no era divisible por 2 no tiene mucho sentido volverse a
preguntar si lo es por 4).
Durante el diseño es posible y aconsejable, realizar comparaciones entre algoritmos que resuelven el
mismo problema. La bondad de un algoritmo puede medirse por dos factores:
-
El tiempo que se necesita para ejecutarlo. Para tener una idea aproximada de ello, basta con saber
el número de instrucciones de cada tipo necesarias para resolver el problema.
Los recursos que se necesitan para implementarlo.
Así, una vez diseñado un primer algoritmo, conviene realizar una evaluación del mismo, cuestión a
veces nada banal y sobre la que volveremos en capítulos posteriores. Si se decide que éste no es
eficiente será necesario o bien diseñar uno nuevo o bien optimizar el original. Optimizar un
algoritmo consiste en introducir modificaciones en él, tendientes a disminuir el tiempo que necesita
para resolver el problema o a reducir los recursos que utiliza. (En el ejemplo 2, el algoritmo se
optimiza si N se declara como primo cuando X supera a N/2 y no esperar hasta que X llegue a N).
Ejemplo:
Realizar la suma de todos los números pares entre 2 y 1000.
El problema consiste en sumar 2 + 4 + 6 + 8 + 10 + . . . + 998 + 1000.
Utilizaremos las palabras SUMA y NUMERO (que llamaremos más tarde variables) para
representar las sumas sucesivas (2 + 4), (2 + 4 + 6), (2 + 4 + 6 + 8), etc.
La solución se puede escribir con el siguiente algoritmo:
1. Inicio.
2. Establecer SUMA a 0.
3. Establecer NUMERO a 2.
4. Sumar NUMERO a SUMA. El resultado será el nuevo valor de la suma (SUMA).
5. Incrementar NUMERO en 2 unidades.
6. Si NUMERO <= 1000 bifurcar (ó, ir) al paso 4; en caso contrario, escribir el último valor
de SUMA y terminar el proceso.
7. Fin.
Informática I. Versión 1.0 Agosto de 2004.
73
Universidad Autónoma de Occidente
Si se estudia con atención cada uno de los algoritmos anteriores descubriremos una serie de
características interesantes que definen la naturaleza de lo que es un algoritmo:
- Un algoritmo resuelve un problema específico: subir una escalera, obtener una tortilla de
patatas, hacer una multiplicación o determinar el máximo común divisor de dos números.
- Un algoritmo es llevado a cabo por una entidad que trabaja en un entorno dado: una persona
cuyo universo inmediato se reduce a su propio cuerpo y una escalera; un cocinero con una sartén,
huevos, patatas, aceite, sal y cebolla; o un niño con lápiz y papel.
- Un algoritmo consta de una serie de pasos que deben llevarse a cabo siguiendo una secuencia
marcada: algunos de los pasos, en uno de los algoritmos anteriores, serían: dar la vuelta a la
tortilla, batir los huevos, pelar las patatas o cascar los huevos; dichos pasos deben aplicarse en un
orden prefijado y no de cualquier manera.
- Un algoritmo se aplica de forma mecánica: un algoritmo no precisa decisiones subjetivas ni
creatividad en su ejecución, cualquiera con una receta adecuada para obtener tortilla de patatas
logrará una tortilla de patatas. Sin embargo, sí es necesario un acto creativo para desarrollar un
nuevo algoritmo.
- Un algoritmo termina en un tiempo finito: todos los algoritmos deben finalizar, pueden tardar
más o menos tiempo en lograr un resultado pero dicho tiempo debe ser finito.
Diseño Descendente (Top Down), ó, Modular
Los problemas complejos se pueden resolver más eficazmente cuando se descomponen en
subproblemas que sean más fáciles de resolver que el original. Este método se denomina divide y
vencerás (Divide and conquere) y consiste en convertir un problema complejo en otros más simples
que, una vez resueltos, en su conjunto nos solucionen el original. Al procedimiento de
descomposición de un problema en subproblemas más simples, llamados módulos, para, a
continuación, seguir dividiendo estos subproblemas en otros más simples (otros módulos), se le
denomina diseño descendente (top down, en inglés). Las ventajas más importantes de este tipo de
diseño son:
1. El problema se comprende más fácilmente al dividirse en módulos o partes más simples.
Adelantemos que cuando demos el salto a la programación, utilizaremos esta idea
constantemente, de forma que hablaremos también de procedimientos, o subprogramas.
2. Las modificaciones en los módulos son más fáciles, pues estamos ante algoritmos más sencillos.
3. La comprobación del problema se puede realizar más fácilmente, al poder localizar los posibles
fallos con mayor precisión.
Refinamiento por pasos
Durante el diseño, entenderemos por refinamiento por pasos, la metodología por la que en un primer
esbozo del algoritmo nos limitamos a señalar o describir un reducido numero de pasos, que deberán
ser expresados con mayor detalle posteriormente. Tras esta primera descripción, éstos se especifican
con mayor minuciosidad, de forma más extensa y con más pasos específicos. En cada nivel de
refinamiento hay que considerar dos fases: ¿Qué hace el módulo? para, a continuación, responder a
¿Cómo lo hace?
Como es natural, dependiendo de la complejidad del problema se necesitarán diferentes y sucesivos
niveles de refinamiento antes de que pueda obtenerse un algoritmo con suficiente nivel de detalle.
Así, en el Ejemplo 1, del cálculo de la longitud de una circunferencia y la superficie de su círculo, a
pesar de presentar en su diseño un bajo nivel de complejidad, se puede descomponer en
subproblemas más simples:
1. leer datos de entrada,
2. calcular superficie y longitud,
3. escribir resultados.
Informática I. Versión 1.0 Agosto de 2004.
74
Universidad Autónoma de Occidente
El ejemplo siguiente, nos muestra el diseño de un algoritmo para un problema de carácter no
numérico
Ejemplo 3:
Diseñar un algoritmo que responda a la pregunta: ¿Qué debo hacer para ver la película XYZ?.
Un primer análisis nos conduce a un esbozo de solución, descomponiéndolo en cuatro módulos
sucesivos:
1.
2.
3.
4.
Ir al cine donde proyectan MatriX
Comprar una entrada
Ver la película
Regresar a casa
Estos cuatro pasos se pueden refinar un poco más y así este problema lo podríamos descomponer de
la siguiente forma:
Algoritmo para ver la película XYZ
inicio
consultar la cartelera de cines
si proyectan XYZ entonces
ir al cine correspondiente
si_no proyectan XYZ
declarar el fracaso del objetivo y terminar
acudir al cine correspondiente
si hay cola entonces ponerse en ella
mientras haya personas delante en la cola hacer
avanzar en la cola
preguntar si quedan entradas
si hay entradas entonces
comprar una entrada
si_no quedan entradas
declarar el fracaso del objetivo, regresar a casa y terminar
encontrar el asiento correspondiente
mientras proyectan la película hacer
ver la película
abandonar el cine
regresar a casa
fin
Algunas de estas acciones son primitivas para nosotros, es decir, no es necesario descomponerlas
más, como el abandonar el cine. Sin embargo hay otras acciones que son susceptibles de mayor
descomposición. Este es el caso de la acción:
“encontrar el asiento correspondiente”
si los números de los asientos están impresos en la entrada, esta acción compuesta se resuelve con el
siguiente algoritmo:
Algoritmo para encontrar el asiento del espectador
inicio
caminar hasta llegar a la primera fila de asientos
repetir
comparar número de fila con número impreso en billete
si no son iguales, entonces pasar a la siguiente fila
hasta_que se localice la fila correcta
Informática I. Versión 1.0 Agosto de 2004.
75
Universidad Autónoma de Occidente
mientras número de asiento no coincida con número de billete
hacer avanzar a través de la fila a la siguiente butaca
sentarse en la butaca
fin
De esta forma, podríamos seguir hasta la descomposición de las distintas acciones en instrucciones
susceptibles de ser interpretadas directamente por el computador.
Programación del Algoritmo
Una vez que el algoritmo está diseñado y representado, se debe pasar a la fase de resolución práctica
del problema con el computador. Esta fase se descompone a su vez en las siguientes subfases: (Ver
Figura 5.3)
1. Codificación del algoritmo en un programa.
2. Ejecución del programa.
Programación
3. Comprobación del programa.
del algoritmo
Codificación en un
programa
Ejecución del
programa
Comprobación
del programa
Fig. 5.3 Programación del algoritmo
La fase de conversión de un algoritmo en instrucciones de un lenguaje de programación, como
sabemos, se denomina codificación. El código deberá estar escrito de acuerdo con la sintaxis del
lenguaje de programación ya que solamente las instrucciones sintácticamente correctas pueden ser
interpretadas por el computador.
Nótese que durante el proceso de programación, se debe separar el diseño del algoritmo de su
posterior implementación en un lenguaje de programación específico. Por ello distinguimos entre el
concepto más general de programación y el más particular de codificación, que depende del lenguaje
de programación utilizado. Al llegar a este punto, es posible que el lector conozca al menos uno de
estos lenguajes y éste es el momento en el que podría mostrar sus habilidades para efectuar una
codificación lo más correcta y eficiente posible.
Tras la codificación del programa, éste deberá ejecutarse en un computador. El resultado de esta
primera ejecución es incierto, ya que existe una alta probabilidad de que aparezcan errores, bien en la
codificación, bien en el propio algoritmo. Por tanto, el paso siguiente consiste en comprobar el
correcto funcionamiento del programa y en asegurarse, en la medida de lo posible, de la validez de
los resultados proporcionados por la máquina.
Formas de describir un algoritmo
Dado que los algoritmos permiten resolver problemas de forma mecánica, está claro que resulta muy
interesante compartir dicho algoritmo de tal manera que otras personas puedan conocerlo y aplicarlo;
así surge el problema de describir los algoritmos de forma tal que todas las características que los
definen se mantengan invariables.
Lenguaje natural. La primera y más sencilla forma de describir un algoritmo es empleando el lenguaje
natural; por ejemplo, el algoritmo para encontrar las raíces de una ecuación de segundo grado (ó,
ecuación cuadrática) podría describirse así:
1. Definir (o, leer) los coeficientes de la ecuación de segundo grado: a, b y c.
2. Determinar el valor del discriminante: d = b 2 - 4ac.
3. Si el discriminante es cero, sólo hay una solución: -b / (2a).
4. Si el discriminante es positivo, hay dos soluciones: (-b ± √d) / (2a).
Informática I. Versión 1.0 Agosto de 2004.
76
Universidad Autónoma de Occidente
5. Si el discriminante es negativo, no hay soluciones reales.
La ventaja fundamental es la facilidad de comprensión, cualquier persona (hispanoparlante, por
supuesto) que lea dicho algoritmo podría entenderlo y aplicarlo; sin embargo, son varios los
problemas que plantea describir un algoritmo de esta forma:
- El lenguaje natural no es universal, este algoritmo sería completamente inútil para los no
hispanoparlantes.
- El lenguaje natural es ambiguo y, por tanto, susceptible de errores.
- El lenguaje natural es demasiado amplio, lo que para una persona puede ser una instrucción
sencilla, puede no serlo para otra y, desde luego, no lo será para un computador.
Por todo ello, se han buscado nuevas formas de describir los algoritmos que, cuando menos, sean más
universales, estén mejor delimitadas y no sean ambiguas; dos técnicas que logran esto son los
organigramas y las notaciones en pseudocódigo.
Diagramas de Flujo (Organigramas)
Los diagramas de flujo u organigramas permiten describir los algoritmos de forma gráfica; para ello
utilizan una serie de bloques que indican distintas circunstancias y flechas que muestran bajo qué
condiciones se pasa de un bloque a otro.
Algunos de los símbolos son los siguientes:
En la página siguiente se muestra un organigrama que describe el algoritmo anterior.
Los organigramas presentan varias ventajas frente al lenguaje natural:
- Los símbolos son universales.
- Son menos propensos a la ambigüedad.
- Por estar basados en un número pequeño de bloques y reglas para su empleo permiten delimitar
mejor los algoritmos.
- Se aproximan más a la forma en que trabaja el ordenador.
Sin embargo:
- El hecho de emplear símbolos supone que una persona que desconozca los símbolos puede tener
dificultades para comprender el algoritmo o no entenderlo en absoluto.
- Aunque los símbolos son universales el texto que se coloca en su interior sigue siendo lenguaje
natural.
- La representación gráfica puede resultar bastante tediosa y en el caso de algoritmos complejos
- extremadamente confusa.
- Un ordenador no es capaz de utilizar una representación visual como descripción de un algoritmo.
Actualmente, los organigramas no son muy utilizados, aunque para mostrar el funcionamiento de
algoritmos sencillos siguen siendo resultando prácticos.
Informática I. Versión 1.0 Agosto de 2004.
77
Universidad Autónoma de Occidente
Pseudocódigo
El pseudocódigo pretende aunar en un solo tipo de representación las ventajas del lenguaje natural y
de los organigramas sin ninguno de sus problemas; por tanto, el pseudocódigo:
- Es fácilmente comprensible para una persona que lo vea por vez primera.
- Está bien delimitado.
- Elimina las ambigüedades del lenguaje natural.
- Se representa de una forma compacta.
De esta forma, el pseudocódigo se suele ver como un subconjunto de un lenguaje natural que
proporciona un número limitado de operaciones para la construcción de algoritmos; la única finalidad
del pseudocódigo (como de los organigramas) es la comunicación entre seres humanos. A
continuación se muestra un ejemplo del algoritmo descrito, mediante un pseudocódigo:
Ejemplo:
Algoritmo para la ecuación cuadrática, escrito en seudocódigo
Informática I. Versión 1.0 Agosto de 2004.
78
Universidad Autónoma de Occidente
escribir ‘Deme los coeficientes y resolveré una ecuación de 2º grado’
escribir ‘¿Cuánto vale A?’
leer a
escribir ‘¿Cuánto vale B?’
leer b
escribir ‘¿Cuánto vale C?’
leer c
b2-4ac
discr
si discr = 0 entonces
s -b/(2a)
escribir ‘Sólo hay una solución:’, s
si no
si discr > 0 entonces
s1 (-b + √discr)/(2a)
s2 (-b - √discr)/(2a)
escribir ‘Las soluciones son:’, s1, s2
si no
escribir ‘No hay soluciones reales.’
fin_si
fin_si
La ventajas del uso del pseudocódigo residen en:
-
Su uso en la planificación de un programa; permitiendo que el programador se pueda
concentrar en la lógica y en las estructuras de control y no tenga que preocuparse, por ahora,
de detalles acerca de las reglas sintácticas y semánticas de un lenguaje específico.
-
Consecuentemente, es más fácil de modificar en el caso de que se descubran errores o anomalías
en la lógica del algoritmo.
-
Aunque el pseudocódigo es independiente del lenguaje de alto nivel que vaya a utilizarse, un
algoritmo expresado en pseudocódigo puede ser traducido más fácilmente a muchos de dichos
lenguajes.
Lenguajes de programación
Aunque en la unidad 4. se revisaron las definiciones de variables numéricas, literales, operadores, etc.;
creemos conveniente recordar esas definicines reforzándolas con ejemplos concretos de otros textos.
Un lenguaje de programación comparte las mismas características que el pseudocódigo pero, además
de ser comprensible para un ser humano, resulta comprensible para un computador; esto es, un
algoritmo descrito mediante un lenguaje de programación puede ser ejecutado por una máquina.
A continuación, se muestra el algoritmo anterior escrito en el lenguaje de programación JAVA:
/*
Ecuación Cuadrática.
Elaborado por:
*****************************************************
*/
import java.io.* ;
// Importa el paquete de entrada / salida (input / output)
class Cuadratica {
// Mètodo principal:
Informática I. Versión 1.0 Agosto de 2004.
79
Universidad Autónoma de Occidente
public static void main( String args[ ] ) throws IOException {
/*
Para recibir los datos vía teclado, debe crear un objeto (que aquí se ha
llamado br) de la clase BufferedReader
Observe que al constructor de la clase BufferedReader se le envía como
argumento una nueva instancia (= objeto) de la clase InputStreamReader
Para obtener esta nueva instancia de la clase InputStreamReader, se ha
enviado a su constructor la variable de clase in de la clase System
*/
// Si lo anterior le parece un trabalenguas, por favor no se alarme,
// no tire la toalla. por el momento, procure memorizar la siguiente línea:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de los coeficientes, del discriminante y de las raíces:
double a, b, c ; // Coeficientes de la ecuación ( a != 0 ).
double d; // Discriminante de la cuadrática: d = b * b - 4 * a * c
double x, x1, x2 ;
// Raíces de la ecuación.
// Lectura, vía teclado, de los coeficientes:
System.out.print( "Digite el valor del coeficiente a (a diferente de cero): " ) ;
a = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor del coeficiente b: " ) ;
b = Double.parseDouble(br.readLine( ) ) ;
System.out.print( "Digite el valor del coeficiente c: " ) ;
c = Double.parseDouble(br.readLine( ) ) ;
// Calcula el discriminante:
d=b*b-4*a*c;
if( d == 0 ) {
x = - b / (2 * a) ;
System.out.println( "Dos raices iguales: X = " + x ) ;
}
else if( d > 0 ) {
x1 = ( - b + Math.sqrt( d ) ) / (2 * a) ;
x2 = ( - b - Math.sqrt( d ) ) / (2 * a) ;
System.out.println( "Raices reales diferentes: " ) ;
System.out.println( " X1 = " + x1 ) ;
System.out.println( " X2 = " + x2 ) ;
}
else
System.out.println( "La ecuacion NO tiene raices reales" ) ;
}
System.exit( 0 ) ;
// Termine el programa (salir del sistema)
}
// Fin del método main( )
// Fin de la clase Cuadratica
Informática I. Versión 1.0 Agosto de 2004.
80
Universidad Autónoma de Occidente
Al compilar y ejecutar esta aplicación Java se obtienen las siguientes salidas en la salida estandar:
Ejemplo:
Supongamos que tenemos un algoritmo para averiguar si un número es par, que puede ser descrito
narrativamente de la siguiente forma: “Si restando consecutivamente doses (2s) del número se
obtiene el numero 2, es par, si se obtiene otro valor (el 1), entonces es impar”. Este algoritmo escrito
en pseudocódigo sería:
leer N
mientras N > 2 hacer
N= N-2
si N = 2 entonces
escribe “es par”
sino
escribe “es impar”
fin_si
Nótese que en este ejemplo y en otros anteriores hemos utilizado dos estructuras que son muy usadas
en programación: mientras-hacer y si-entonces - si_no; y que la escritura del pseudocódigo usa
Informática I. Versión 1.0 Agosto de 2004.
81
Universidad Autónoma de Occidente
normalmente la indentación (sangría en el margen izquierdo) de diferentes líneas para ayudar a
delimitar visualmente cada una de las estructuras utilizadas. El siguiente es el programa escrito en
Java:
import java.io.* ;
class EsPar1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int n ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
n = Integer.parseInt( br.readLine( ) ) ;
// Ciclo while que verifica si n es par:
while(n > 2) {
n=n-2;
}
if(n == 2)
System.out.println( "El numero ingresado es par" ) ;
else
System.out.println( "El numero ingresado es impar" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
}
// Fin de la clase EsPar1
Variables
Una variable es una localización o casilla en la memoria principal que almacena un valor que puede
cambiar en el transcurso de la ejecución del programa. Cuando un programa necesita almacenar un
dato, necesita una variable. Toda variable tiene un nombre, un tipo de dato y un valor. Antes de
poder utilizar una variable es necesario declararla especificando su nombre y su tipo de dato. Para
declarar variables usaremos los siguientes formatos:
Informática I. Versión 1.0 Agosto de 2004.
82
Universidad Autónoma de Occidente
Declaración de una variable:
tipo nombre
Declaración de varias variables con el mismo tipo de dato:
tipo nombre1, nombre2, nombre3, ..., nombreN
Donde:
Es el tipo de dato de la variable que puede ser: ENTERO (si la
variable almacenará un número entero) , REAL (si la variable
almacenará un número con parte decimal) , CARACTER (si la
variable almacenará un caracter), CADENA (si la variable
almacenará un conjunto de caracteres) o LOGICO (si la variable
almacenará el valor verdadero o el valor falso).
nombre1, nombre2, ..., Nombres de las variables. El nombre de una variable debe comenzar
nombreN
con una letra, un símbolo de subrayado o un símbolo de dólar. Los
demás caracteres del nombre pueden ser letras, números, símbolos
de subrayado o símbolos de dólar. Debe considerarse también que
una letra mayúscula se considera diferente de una letra minúscula.
Tipo
Ejemplo Declaración de variables.
La siguiente instrucción declara la variable edad de tipo ENTERO y la variable descuento de tipo
REAL.
ENTERO edad
REAL descuento
Esto crea las casillas de memoria edad y descuento. Luego de la creación, las variables están
indefinidas ( ? ).
Edad
?
descuento ?
La siguiente instrucción declara las variables nota1, nota2 y nota3, todas de tipo ENTERO.
ENTERO nota1, nota2, nota3
Esto crea los casilleros de memoria nota1, nota2 y nota3. Luego de la creación, las variables están
indefinidas ( ? ).
nota1 ?
nota2 ?
nota3 ?
Literales
Se denominan literales a todos aquellos valores que figuran en el pseudocódigo y pueden ser:
Literales enteros 12, 20300, 15, etc.
Literales reales 3.1416, 2345.456, etc.
Informática I. Versión 1.0 Agosto de 2004.
83
Universidad Autónoma de Occidente
Literales de carácter 'a', 'B', ';', '<', '+', etc.
Literales de cadena
"Hola", "Algoritmos Computacionales", etc.
Literales lógicos verdadero, falso
Instrucciones Algorítmicas Básicas
Existen tres instrucciones algorítmicas básicas que son las siguientes:
1.- Entrada
Consiste en obtener un dato de un dispositivo de entrada, como el teclado, y almacenarlo en una
variable. En general, la acción de ingresar un dato a una variable se expresa en el pseudocódigo
mediante la palabra LEER, de la siguiente forma:
LEER variable
Por ejemplo, la instrucción:
LEER estatura
Solicita el ingreso de un valor, desde algún dispositivo de entrada (como el teclado), para la
variable estatura.
2.- Salida
Consiste en mostrar el valor de una variable en un dispositivo de salida, como la pantalla. En
general, la acción de mostrar el valor de una variable se expresa en el pseudocódigo mediante la
palabra IMPRIMIR de la siguiente forma:
IMPRIMIR variable
Por ejemplo, la instrucción:
IMPRIMIR importeCompra
Muestra, en algún dispositivo de salida (como la pantalla), el valor de la variable
importeCompra.
3.- Asignación
Consiste en asignar a (ó, almacenar en) una variable el valor de una expresión. La expresión
puede ser una simple variable, un simple literal o una combinación de variables, literales y
operadores. La asignación se expresa en el pseudocódigo de la siguiente forma:
variable = expresión
Donde variable y el valor de expresión deben tener el mismo tipo de dato!!
Cuando se asigna un valor ENTERO a una variable REAL, entonces el valor ENTERO se
convertirá en REAL antes de almacenarse. Así, al asignar el valor ENTERO 25 a una variable
REAL, se almacenará 25.0.
Ejemplo:- Algoritmo para expresar en centímetros y pulgadas una cantidad dada en metros.
Esta es una solución en pseudocódigo utilizando conceptos computacionales de: variable, entrada de
datos y salida de resultados. La solución considera que 1 metro = 100 centímetros y que 1 pulgada =
2.54 centímetros.
INICIO
// Declara las variables M, C y P
REAL M, C, P
Informática I. Versión 1.0 Agosto de 2004.
84
Universidad Autónoma de Occidente
// Solicita el ingreso de la cantidad en metros
LEER M
// Calcula la cantidad en centímetros y lo asigna a la variable C
C = M * 100
// Calcula la cantidad en pulgadas y lo asigna a la variable P
P = C / 2.54
// Muestra los valores de las variables C y P
IMPRIMIR C, P
FIN
Expresiones Aritméticas
Una expresión aritmética es una combinación de variables, literales y operadores aritméticos.
Operadores Aritméticos
En la tabla que sigue se muestran los operadores aritméticos que vamos a utilizar.
Tabla 5.1 Operadores aritméticos
Operador
+
*
/
%
Significado
Suma
Resta
Multiplicación
División
Residuo
Ejemplo
a +b
a-b
a *b
a/b
a%b
Los operadores aritméticos pueden utilizarse con tipos enteros y reales. Si en una operación con dos
operandos, ambos operandos son enteros, el resultado es un entero; si alguno de ellos es real, el
resultado es real. Así, 15 / 4 es 3 y no 3.75; en cambio, 15.0/4 es 3.75.
Reglas de jerarquía de los operadores aritméticos
Cuando una expresión aritmética tiene más de un operador aritmético, el orden de aplicación de los
operadores sigue un orden preciso determinado por las reglas de jerarquía de los operadores
aritméticos, que se muestran en la siguiente tabla:
Tabla 5.2 Reglas de jerarquía de los operadores aritméticos
Operador
()
*, /, %
+, -
Orden de evaluación
Se evalúan en primer lugar
Se evalúan en segundo lugar
Se evalúan en tercer lugar
Si existen paréntesis anidados, se evalúa primero la expresión en el paréntesis más interno. Si varios
operadores o paréntesis tienen la misma jerarquía, la evaluación será de izquierda a derecha.
Ejemplo:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?
Informática I. Versión 1.0 Agosto de 2004.
85
Universidad Autónoma de Occidente
Solución
e=a/b/c
Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha:
Primero, se dividirá a entre b.
Segundo, el resultado ya obtenido de a / b se dividirá entre c.
Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere
ninguna pareja de paréntesis.
Ejemplo:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?
Solución
c=a*b*c/d/e
Como todos los operadores tienen la misma jerarquía, la evaluación será de izquierda a derecha:
Primero, se multiplicará a por b.
Segundo, el resultado ya obtenido de a * b se multiplicará por c.
Tercero, el resultado ya obtenido de a * b * c se dividirá entre d.
Cuarto, el resultado ya obtenido de a * b * c / d se divivirá entre e.
Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo que no se requiere
ninguna pareja de paréntesis.
Ejercicio:- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión algebraica?
Solución
e = 4 / ( (a + b) / (c / d) ) + v / (w / p) + 5 * m * n * q
Aplicando las reglas de jerarquía de los operadores aritméticos:
Primero, se sumará a más b.
Segundo, se dividirá c entre d.
Tercero, el resultado ya obtenido de a+b se dividirá entre el resultado ya obtenido de c/d.
Cuarto, se dividirá 4 entre el resultado ya obtenido de ( (a+b)/(c/d) )
Quinto, se dividirá w entre p.
Sexto, se dividirá v entre el resultado ya obtenido de (w/p).
Séptimo, se multiplicará 5 por m.
Octavo, se multiplicará el resultado ya obtenido de 5*m por n.
Noveno, se multiplicará el resultado ya obtenido de 5*m*n por q.
Décimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) más el resultado ya obtenido de
v/(w/p).
Undécimo, se sumará el resultado ya obtenido de 4/( (a+b)/(c/d) ) + v/(w/p) más el resultado ya
obtenido de 5*m*n*q.
Informática I. Versión 1.0 Agosto de 2004.
86
Universidad Autónoma de Occidente
Se ha utilizado la mínima cantidad posible de paréntesis. Pueden usarse paréntesis adicionales, lo que
no es un error. Por ejemplo, otra solución posible que arroja el mismo resultado final es:
e = ( 4/( (a+b)/(c/d) ) ) + (v/(w/p)) + (5*m*n*q)
Note que usando correctamente las reglas de jerarquía, es posible usar menos parejas de paréntesis.
Expresiones Lógicas
Una expresión lógica combina variables, literales, operadores aritméticos, operadores relacionales y
operadores lógicos. Los operadores relacionales y los operadores lógicos se muestran en las tablas 1.3
y 1.4
Tabla 5.3 Operadores relacionales
Operador Significado
Ejemplo
>
mayor que
a>b
>=
mayor o igual que
a >= b
<
menor que
a<b
<=
menor o igual que
a <= b
==
igual a
a == b
!=
diferente de
a != b
Operador
!
&&
||
Tabla 5.4 Operadores lógicos
Significado
Ejemplo
No (Not)
!a
Y (And)
a && b
Ó (Or)
a || b
EJERCICIOS RESUELTOS
Ejercicio 1:- Diseñe un pseudocódigo que halle el área y el perímetro de un rectángulo. Considere
que: area = base x altura, y, perimetro = 2 x (base+altura).
Algoritmo
INICIO
// Declaración de variables
REAL base, altura, area, perimetro
// Entrada de datos
LEER base, altura
// Proceso de cálculo
area = base*altura
perimetro = 2*(base+altura)
// Salida de resultados
IMPRIMIR area, perimetro
FIN
Veamos el algoritmo anterior escrito en Java:
Informática I. Versión 1.0 Agosto de 2004.
87
Universidad Autónoma de Occidente
import java.io.* ;
class Rectangulo1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double base, altura, area, perimetro ;
// Entrado de datos:
System.out.print( "Digite el valor de la base [cm]: " ) ;
base = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la altura [cm]: " ) ;
altura = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
area = base * altura ;
perimetro = 2 *(base + altura) ;
// Salida de resultados
System.out.println( "Area del rectangulo: " + area + " cm2" ) ;
System.out.println( "Perimetro del rectangulo: " + perimetro + " cm" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
}
// Fin de la clase Rectangulo1
Salida:
Ejercicio 2:- Diseñe un pseudocódigo para convertir una longitud dada en metros a sus equivalentes
en centímetros, pies, pulgadas y yardas. Considere que: 1 metro = 100 centímetros, 1 pulgada = 2.54
centimetros, 1 pie = 12 pulgadas, 1 yarda = 3 pies.
Algoritmo
INICIO
// Declaración de variables
REAL cmetr,ccent, cpies, cpulg, cyard
Informática I. Versión 1.0 Agosto de 2004.
88
Universidad Autónoma de Occidente
// Entrada de datos
LEER cmetr
// Proceso de cálculo
ccent = cmetr * 100
cpulg = ccent / 2.54
cpies = cpulg / 12
cyard = cpies / 3
// Salida de resultados
IMPRIMIR ccent, cpulg, cpies, cyard
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class Conversiones1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double cmetr,ccent, cpies, cpulg, cyard ;
// Entrado de datos:
System.out.print( "Digite la cantidad en metros: " ) ;
cmetr = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
ccent = cmetr * 100 ;
cpulg = ccent / 2.54 ;
cpies = cpulg / 12 ;
cyard = cpies / 3 ;
// Salida de resultados
System.out.println( "Cantidad equivalente en centimetros: " + ccent + " cm" ) ;
System.out.println( "Cantidad equivalente en pulgadas: " + cpulg + " pulgadas" ) ;
System.out.println( "Cantidad equivalente en pies: " + cpies + " pies" ) ;
System.out.println( "Cantidad equivalente en yardas: " + cyard + " yardas" ) ;
System.exit( 0 ) ;
} //Fin del método main( )
Informática I. Versión 1.0 Agosto de 2004.
89
Universidad Autónoma de Occidente
}
// Fin de la clase Conversiones1
Ejercicio 3:- Una institución benéfica europea ha recibido tres donaciones en soles, dolares y marcos.
La donación será repartida en tres rubros: 70% para la implementación de un centro de salud, 20%
para un comedor de niños y el resto para gastos administrativos. Diseñe un algoritmo que determine el
monto en euros que le corresponde a cada rubro. Considere que: 1 dólar = 3.52 soles, 1 dólar = 2.08
marcos, 1 dólar = 1.07 euros.
Algoritmo
INICIO
// Declaración de variables
REAL csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3
// Entrada de datos
LEER csoles, cdolares, cmarcos
// Proceso de cálculo
ceuros = (csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07
rubro1 = ceuros * 0.70
rubro2 = ceuros * 0.20
rubro3 = ceuros * 0.10
// Salida de resultados
IMPRIMIR rubro1, rubro2, rubro3
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class Euros1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double csoles, cdolares, cmarcos, ceuros, rubro1, rubro2, rubro3 ;
// Entrada de datos:
System.out.print( "Digite la cantidad de dinero en soles: $ " ) ;
csoles = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite la cantidad de dinero en dolares: U$ " ) ;
Informática I. Versión 1.0 Agosto de 2004.
90
Universidad Autónoma de Occidente
cdolares = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite la cantidad de dinero en marcos: $ " ) ;
cmarcos = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
ceuros = ( csoles / 3.52 + cdolares + cmarcos / 2.08 ) * 1.07 ;
rubro1 = ceuros * 0.70 ;
rubro2 = ceuros * 0.20 ;
rubro3 = ceuros * 0.10 ;
// Salida de resultados
System.out.println( "Rubro 1 para salud: $ " + rubro1 + " euros" ) ;
System.out.println( "Rubro 2 para comedor: $ " + rubro2 + " euros" ) ;
System.out.println( "Rubro 3 para gastos de admon: $ " + rubro3 + " euros" ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase Euros1
Ejercicio 4:- En una competencia atlética de velocidad el tiempo se mide en minutos, segundos y
centésimas de segundo y, el espacio recorrido se mide en metros. Diseñe un algoritmo para determinar
la velocidad promedio de un atleta en km/hr. Considere que: 1 hora = 60 minutos, 1 minuto = 60
segundos, 1 segundo = 100 centésimas de segundo, 1 kilómetro = 1000 metros.
Algoritmo
INICIO
// Declaración de variables
ENTERO tmin, tseg, tcen
REAL thor, velkmhr, espmt, espkm
// Entrada de datos
LEER tmin, tseg, tcen, espmt
// Cálculo del tiempo total empleado en horas
thor = tmin / 60 + tseg / 3600 + (tcen / 100) / 3600 // Aquí sobran los paréntesis. Se dejan por
// claridad.
// Cálculo del espacio recorrido en kilómetros
espkm = espmt / 1000
Informática I. Versión 1.0 Agosto de 2004.
91
Universidad Autónoma de Occidente
// Cálculo de la velocidad en km/hr
velkmhr = espkm / thor
// Salida de resultados
IMPRIMIR velkmhr
FIN
Veamos el algoritmo anterior escrito en Java:
import java.io.* ;
class VelocidadAtleta1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int tmin, tseg, tcen ;
double espmt, thor, espkm, velkmhr ;
// Entrada de datos:
System.out.print( "Digite el tiempo empleado en minutos: " ) ;
tmin = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el tiempo empleado en segundos: " ) ;
tseg = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el tiempo empleado en centesimas de segundos: " ) ;
tcen = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el espacio recorrido en metros: " ) ;
espmt = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo
// Cálculo del tiempo total empleado en horas:
thor = tmin / 60.0 + tseg / 3600.0 + (tcen / 100.0) / 3600.0 ; // Aquí sobran los
// paréntesis. Se dejan por claridad.
// Cálculo del espacio recorrido en kilómetros:
espkm = espmt / 1000 ;
// Cálculo de la velocidad en km/hr:
velkmhr = espkm / thor ;
// Salida de resultados
System.out.println( "Velocidad del atleta: " + velkmhr + " Km / Hr." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase VelocidadAtleta1
Informática I. Versión 1.0 Agosto de 2004.
92
Universidad Autónoma de Occidente
Ejercicio 5:- Diseñe un algoritmo que determine la cifra de las unidades de un número natural.
Solución 1
Análisis
Puede comprobarse que la cifra de las unidades de un número es igual al resto de la división del
número entre 10. Observe para ello las siguientes divisiones:
3245 | 10
5 324
768 | 10
8 76
9 | 10
9
0
Podemos concluir entonces que:
unidades = numero % 10
Siendo % el operador residuo. Este operador permite obtener el residuo de una división, así como /
permite obtener el cociente.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero, unidades
// Entrada de datos
LEER numero
// Proceso de cálculo
unidades = numero % 10
// Salida de resultados
IMPRIMIR unidades
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class UnidadesNumero1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
Informática I. Versión 1.0 Agosto de 2004.
93
Universidad Autónoma de Occidente
unidades = num % 10 ;
System.out.println( num + " tiene " + unidades +
" como cifra de las unidades." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
}
// Fin de la clase UnidadesNumero1
Salida:
Solución 2
Análisis
El residuo de una división entera puede obtenerse también sin recurrir al operador %, de la siguiente
forma:
unidades = numero - (numero / 10) * 10
observe para esto que en la división (numero/10) los operandos son enteros por lo que el cociente
será un entero. Así por ejemplo, si numero es igual a 3245, la división (numero/10) produce 324,
aunque matemáticamente sea 324.5; es decir, se descarta la parte decimal.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero, unidades
// Entrada de datos
LEER numero
// Proceso de cálculo
unidades = numero - (numero / 10) * 10
// Salida de resultados
IMPRIMIR unidades
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class UnidadesNumero2 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
Informática I. Versión 1.0 Agosto de 2004.
94
Universidad Autónoma de Occidente
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
unidades = num - (num / 10) * 10 ;
System.out.println( num + " tiene " + unidades +
" como cifra de las unidades." ) ;
System.exit( 0 ) ;
} //Fin del método main( )
}
// Fin de la clase UnidadesNumero2
Salida:
Ejercicio 6:- Diseñe un algoritmo que determine la suma de las cifras de un número entero positivo
de 4 cifras.
Solución 1
Análisis
Las cifras pueden ser obtenidas mediante divisiones sucesivas entre 10. Para el efecto, considere el
caso de un número N igual a 3245:
unidades = N % 10
cociente = N / 10
3245 | 10
5 324
decenas = cociente % 10
cociente = cociente / 10
324 | 10
4 32
centenas = cociente % 10
millares = cociente / 10
32
2
| 10
3
Algoritmo
INICIO
// Declaración de variables
ENTERO N, suma, millares, centenas, decenas, unidades
// Entrada de datos
Informática I. Versión 1.0 Agosto de 2004.
95
Universidad Autónoma de Occidente
LEER N
// Proceso de cálculo
unidades = N % 10
cociente = N / 10
decenas = cociente % 10
cociente = cociente / 10
centenas = cociente % 10
millares = cociente/10
suma
= unidades + decenas + centenas + millares
// Salida de resultados
IMPRIMIR suma
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class SumaCifrasNum1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades, decenas, centenas, millares, cociente, suma ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
unidades = num % 10 ;
cociente = num / 10 ;
decenas = cociente % 10 ;
cociente = cociente / 10 ;
centenas = cociente % 10 ;
millares = cociente / 10 ;
suma = unidades + decenas + centenas + millares ;
System.out.println( "Suma de las cifras del numero: " + suma ) ;
Informática I. Versión 1.0 Agosto de 2004.
96
Universidad Autónoma de Occidente
}
}
System.exit( 0 ) ;
//Fin del método main( )
// Fin de la clase SumaCifrasNum1
Salida:
Solución 2
Análisis 2
Considerando que el número tiene 4 cifras, las cifras también pueden ser obtenidas mediante
divisiones sucesivas entre 1000, 100 y 10. Para el efecto, considere el caso de un número N igual a
3245:
millares = N / 1000
resto = N % 1000
centenas = resto / 100
resto = resto % 100
decenas = resto / 10
unidades = resto % 10
3245 | 1000
245 3
245 | 100
45 2
45 | 10
5 4
Algoritmo
INICIO
// Declaración de variables
ENTERO N, suma, millares, centenas, decenas, unidades, resto
// Entrada de datos
LEER N
// Proceso de cálculo
millares = N / 1000
resto = N % 1000
centenas = resto / 100
resto = resto % 100
decenas = resto / 10
unidades = resto % 10
suma = unidades + decenas + centenas + millares
// Salida de resultados
IMPRIMIR suma
FIN
El algoritmo anterior, escrito en Java, queda así:
import java.io.* ;
class SumaCifrasNum2 {
Informática I. Versión 1.0 Agosto de 2004.
97
Universidad Autónoma de Occidente
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int num, unidades, decenas, centenas, millares, resto, suma ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo de 4 cifras: " ) ;
num = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
millares = num / 1000 ;
resto = num % 1000 ;
centenas = resto / 100 ;
resto = resto % 100 ;
decenas = resto / 10 ;
unidades = resto % 10 ;
suma = unidades + decenas + centenas + millares ;
System.out.println( "Suma de las cifras del numero: " + suma ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase SumaCifrasNum2
Salida:
Ejercicio 7:- Diseñe un algoritmo que lea la hora actual del día HH:MM:SS y determine cuántas
horas, minutos y segundos restan para culminar el día.
Algoritmo
INICIO
// Declaración de variables
ENTERO hor1, min1, seg1, hor2, min2, seg2, segres, resto
Informática I. Versión 1.0 Agosto de 2004.
98
Universidad Autónoma de Occidente
// Entrada de datos
LEER hor1, min1, seg1
// Cálculo de la cantidad de segundos que restan para culminar el día
segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1)
// Descomposición de segres en horas, minutos y segundos
hor2 = segres / 3600
resto = segres % 3600
min2 = resto / 60
seg2 = resto % 60
// Salida de resultados
IMPRIMIR hor2, min2, seg2
FIN
Así queda en Java:
import java.io.* ;
class HmsQueFaltan1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int hor1, min1, seg1, hor2, min2, seg2, segres, resto ;
// Entrada de datos:
System.out.print( "Digite la hora MILITAR actual (numero entero): " ) ;
hor1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los minutos actuales (numero entero): " ) ;
min1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los segundos actuales (numero entero): " ) ;
seg1 = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo.
// *******************
// Cálculo de la cantidad de segundos que restan para culminar el día:
segres = 86400 - (hor1 * 3600 + min1 * 60 + seg1) ;
// Descomposición de segres en horas, minutos y segundos:
hor2 = segres / 3600 ;
resto = segres % 3600 ;
min2 = resto / 60 ;
seg2 = resto % 60 ;
Informática I. Versión 1.0 Agosto de 2004.
99
Universidad Autónoma de Occidente
// Salida de resultados
System.out.println( "Para terminar el dia, hacen falta: " +
hor2 + " horas, " + min2 + " minutos y " + seg2 + " segundos." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase HmsQueFaltan1
Salida:
Ejercicio 8:- Diseñe un algoritmo para sumar dos tiempos dados en horas, minutos y segundos.
Algoritmo
INICIO
// Declaración de variables
ENTERO hor1, min1, seg1, hor2, min2, seg2, hor3, min3, seg3, totseg, resto
// Entrada de datos
LEER hor1, min1, seg1, hor2, min2, seg2
// Determina la cantidad total de segundos entre los dos tiempos
totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2)
// Descompone totseg en horas, minutos y segundos
hor3 = totseg / 3600
resto = totseg % 3600
min3 = resto / 60
seg3 = resto % 60
// Salida de resultados
IMPRIMIR hor3, min3, seg3
FIN
Así queda en Java:
import java.io.* ;
class HmsQueFaltan2 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004.
100
Universidad Autónoma de Occidente
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int hor1, min1, seg1, hor2, min2, seg2, hor3, min3, seg3, totseg, resto ;
// Entrada de datos:
System.out.print( "Digite la primera hora (numero entero): " ) ;
hor1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los minutos de la primera hora (numero entero): " ) ;
min1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los segundos de la primera hora (numero entero): " ) ;
seg1 = Integer.parseInt( br.readLine( ) ) ;
System.out.println( "**********************************************" ) ;
System.out.print( "Digite la segunda hora (numero entero): " ) ;
hor2 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los minutos de la segunda hora (numero entero): " ) ;
min2 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite los segundos de la segunda hora (numero entero): " ) ;
seg2 = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo.
// *******************
// Determina la cantidad total de segundos entre los dos tiempos:
totseg = (hor1 + hor2) * 3600 + (min1 + min2) * 60 + (seg1 + seg2) ;
// Descompone totseg en horas, minutos y segundos:
hor3 = totseg / 3600 ;
resto = totseg % 3600 ;
min3 = resto / 60 ;
seg3 = resto % 60 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados
System.out.println( "La suma de los dos tiempos da: " + hor3 +
" horas, " + min3 + " minutos y " + seg3 + " segundos." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase HmsQueFaltan2
Informática I. Versión 1.0 Agosto de 2004.
101
Universidad Autónoma de Occidente
Salida:
Ejercicio 9:- El sueldo neto de un vendedor se calcula como la suma de un sueldo básico de
$2’500.000.oo más el 12% del monto total vendido. Diseñe un algoritmo que determine el sueldo
neto de un vendedor sabiendo que hizo tres ventas en el mes.
Algoritmo
INICIO
// Declaración de variables
REAL venta1, venta2, venta3, ventatot, comision, sueldoneto
// Entrada de datos
LEER venta1, venta2, venta3
// Proceso de cálculo
ventatot = venta1 + venta2 + venta3
comision = ventatot * 12 / 100
sueldoneto = 2500000 + comision
// Salida de resultados
IMPRIMIR sueldoneto
FIN
Así queda en Java:
import java.io.* ;
class SueldoNeto1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de una constante:
final float $BASICO = 2500000 ;
// Declaración de variables:
float venta1, venta2, venta3, ventatot, comision, sueldoneto ;
// Entrada de datos:
Informática I. Versión 1.0 Agosto de 2004.
102
Universidad Autónoma de Occidente
System.out.print( "Digite el valor de la primera venta: $ " ) ;
venta1 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el valor de la segunda venta: $ " ) ;
venta2 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el valor de la tercera venta: $ " ) ;
venta3 = Float.parseFloat( br.readLine( ) ) ;
// Proceso de cálculo:
ventatot = venta1 + venta2 + venta3 ;
comision = ventatot * 12 / 100 ;
sueldoneto = $BASICO + comision ;
System.out.println( "**********************************************" ) ;
// Salida de resultados
System.out.println( "Venta total: $ " + ventatot ) ;
System.out.println( "Comision: $ " + comision ) ;
System.out.println( "Sueldo neto: $ " + sueldoneto ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase SueldoNeto1
Salida:
Nota: $ 1.2E7 = $ 1.2 x 10 7 = $ 12000000
Ejercicio 10:- Diseñe un algoritmo que determine el porcentaje de varones y de mujeres que hay en
un salón de clases.
Algoritmo
INICIO
// Declaración de variables
REAL porcvar, porcmuj
ENTERO varones, mujeres, total
// Entrada de datos
LEER varones, mujeres
// Proceso de cálculo
Informática I. Versión 1.0 Agosto de 2004.
103
Universidad Autónoma de Occidente
total = varones + mujeres
porcvar = varones * 100.0 / total
porcmuj = mujeres * 100.0 / total
// Salida de resultados
IMPRIMIR porcvar, porcmuj
FIN
En Java:
import java.io.* ;
class MujHom1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double porcvar, porcmuj ;
int varones, mujeres, total ;
// Entrada de datos:
System.out.print( "Digite el numero de Damas: " ) ;
mujeres = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de Caballeros: " ) ;
varones = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
total = varones + mujeres ;
porcvar = varones * 100.0 / total ;
porcmuj = mujeres * 100.0 / total ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "Porcentaje de mujeres: " + porcmuj + " %" ) ;
System.out.println( "Porcentaje de hombres: " + porcvar + " %" ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase MujHom1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
104
Universidad Autónoma de Occidente
Ejercicio 11:- En países de habla inglesa es común dar la estatura de una persona como la suma de
una cantidad entera de pies más una cantidad entera de pulgadas. Así, la estatura de una persona
podría ser 3' 2" ( 3 pies 2 pulgadas ). Diseñe un algoritmo que determine la estatura de una persona
en metros, conociendo su estatura en el formato inglés. Considere que: 1 pie = 12 plg, 1 plg = 2.54
cm, 1 m = 100 cm.
Algoritmo
INICIO
// Declaración de variables
REAL estmt
ENTERO cpies, cplgs
// Entrada de datos
LEER cpies, cplgs
// Proceso de cálculo
estmt = (cpies * 12 + cplgs) * 2.54 / 100
// Salida de resultados
IMPRIMIR estmt
FIN
En Java:
import java.io.* ;
class EstaturaMts1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int cpies, cplgs ;
double estmt ;
// Entrada de datos:
System.out.print( "De la estatura, digite el numero (entero) de pies: " ) ;
cpies = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "De la estatura, digite el numero (entero) de pulgadas: " ) ;
cplgs = Integer.parseInt( br.readLine( ) ) ;
Informática I. Versión 1.0 Agosto de 2004.
105
Universidad Autónoma de Occidente
// Proceso de cálculo:
estmt = (cpies * 12 + cplgs) * 2.54 / 100 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "En metros, su estatura es: " + estmt + " mts." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase EstaturaMts1
Salida:
Ejercicio 12:- Diseñe un algoritmo que exprese la capacidad de un disco duro en megabytes,
kilobytes y bytes, conociendo la capacidad del disco en gigabytes. Considere que: 1 kilobyte = 1024
bytes, 1 megabyte = 1024 kilobyte, 1 gigabyte = 1024 megabytes.
Algoritmo
INICIO
// Declaración de variables
REAL cgigabyte, cmegabyte, ckilobyte, cbyte
// Entrada de datos
LEER cgigabyte
// Proceso de cálculo
cmegabyte = cgigabyte * 1024
ckilobyte = cmegabyte * 1024
cbyte = ckilobyte * 1024
// Salida de resultados
IMPRIMIR cmegabyte, ckilobyte, cbyte
FIN
En Java:
Informática I. Versión 1.0 Agosto de 2004.
106
Universidad Autónoma de Occidente
import java.io.* ;
class CapacidadDiscoDuro1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
double cgigabyte, cmegabyte, ckilobyte, cbyte ;
// Entrada de datos:
System.out.print( "Digite la capacidad del Disco Duro en Gigabytes: " ) ;
cgigabyte = Double.parseDouble( br.readLine( ) ) ;
// Proceso de cálculo:
cmegabyte = cgigabyte * 1024 ;
ckilobyte = cmegabyte * 1024 ;
cbyte = ckilobyte * 1024 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "La capacidad del Disco Duro es: " + cmegabyte +
" Megabytes,\n" + ckilobyte + " Kilobytes y\n" + cbyte + " Bytes." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase CapacidadDiscoDuro1
Salida:
Ejercicio 13:- Diseñe un algoritmo que intercambie las cifras de las unidades de dos números
naturales.
Algoritmo
INICIO
// Declaración de variables
ENTERO numero1, numero2, unidades1, unidades2
Informática I. Versión 1.0 Agosto de 2004.
107
Universidad Autónoma de Occidente
// Entrada de datos
LEER numero1, numero2
// Determina las cifras de las unidades
unidades1 = numero1 % 10
unidades2 = numero2 % 10
// Intercambia las cifras de las unidades
numero1 = numero1 - unidades1 + unidades2
numero2 = numero2 - unidades2 + unidades1
// Salida de resultados
IMPRIMIR numero1, numero2
FIN
En Java:
import java.io.* ;
class IntercambiarUnidades1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int numero1, numero2, unidades1, unidades2 ;
// Entrada de datos:
System.out.print( "Digite un numero entero positivo: " ) ;
numero1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite otro numero entero positivo: " ) ;
numero2 = Integer.parseInt( br.readLine( ) ) ;
// Proceso de cálculo:
// *******************
// Determina las cifras de las unidades en cada número:
unidades1 = numero1 % 10 ;
unidades2 = numero2 % 10 ;
// Intercambia solo las cifras de las unidades:
numero1 = numero1 - unidades1 + unidades2 ;
numero2 = numero2 - unidades2 + unidades1 ;
System.out.println( "**********************************************" ) ;
// Salida de resultados:
System.out.println( "Despues de intercambiar la cifra de las unidades,\n" +
"los numeros quedan asi:\nPrimer numero: " + numero1 +
Informática I. Versión 1.0 Agosto de 2004.
108
Universidad Autónoma de Occidente
"\nSegundo numero: " + numero2 ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase IntercambiarUnidades1
Salida:
Ejercicios sobre algoritmos
1.- ¿Defina qué es un algoritmo y cuales son sus características?
2.-¿Qué son y para qué sirven los diagramas de flujo?
3.-¿Qué es pseudocódigo?
4.-¿Cuales son los tipos de datos que existen?
5.- Diga cuál es máximo número que se puede representar con un entero sin signo de 2, 4 y 8 bytes.
6.- Defina cada uno de los operadores aritméticos, relacionales y lógicos.
7.- Defina los siguientes términos:
Constante
Variable
Expresión
8.- Codifique en código Java las siguientes expresiones algebraicas:
Informática I. Versión 1.0 Agosto de 2004.
109
Universidad Autónoma de Occidente
a.
100 − 200
A−5
b.15 −
e. a + b 3
A2
3
c. a 2 + b 2 − 35c
d. 5 X 2 − 3X + 5
g. Coseno 2 (3X ) + Seno(Y )
f . a 10 − 5
9.- Haga la secuencia de evaluación de la expresión algebraica que haría el computador para:
(3 * 9 - 3 + 5/2 ) + 9 MOD 3 + (8 * 3 - 5) * (2/4) + (5 * 3 * 2 + 1) =
10.- Haga la codificación Java de la expresión algebraica:
a 2 + b 2 58 − 3x − 54
=
3,4 x − 2,1y
11.- Evalúe el resultado para a = 7, b = 2, x = 2, y = 1.
Ejercicios sobre algoritmos Secuenciales
1.- Diseñe un algoritmo que calcule el área de un triángulo en función de las longitudes de sus lados.
área=
p(p - a)(p - b)(p - c)
donde p = (a+b+c)/2 = (semiperímetro)
2.- Elaborar un algoritmo que permita calcular el volumen de un cilindro (radio y altura se ingresan
desde el teclado). (volumne cilindro => π radio 2 x altura)
3.- Haga un algoritmo que calcule
a. Área de un circulo
=> Área = π r 2
b. Área de un triángulo => Área =
b×h
2
4.- Diseñar un algoritmo a través del cual se pueda calcular la siguiente expresión algebraica :
z=
y1 − y 2
x1 − x 2
5.- Diseñe un algoritmo para la conversión una medida de metros a pies y pulgadas.
6.- Elabore un algoritmo que convierta una temperatura dada en centígrados a fahrenheit.
Informática I. Versión 1.0 Agosto de 2004.
110
Universidad Autónoma de Occidente
7.- Dado un carácter alfabético en mayúsculas, elabore un algoritmo que imprima en pantalla su
equivalente en minúscula (consulte el código ASCII).
8.- Hacer un algoritmo para calcular el IVA (16%) de un valor digitado por el teclado, mostrar este
resultado y el de sumar el IVA al valor digitado.
Ejemplo: valor digitado => 1000
mostrar en pantalla IVA = 160 y valor mas IVA = 1160
9.- Elabore un algoritmo para mostrar la cantidad de miles, centenas, decenas y unidades de un
número entero digitado por teclado.
Ejemplo: Sea 1483 el número digitado el algoritmo debe mostrar en pantalla
Miles
= 1
Centenas = 4
Decenas = 8
Unidades = 3
10.- Las funciones trigonométricas calculan sus valores para ángulos dados en unidades de radianes,
haga un algoritmo que pase ángulos de grados a radianes, y calcule la tangente del ángulo
convertido a radianes usando las funciones seno y coseno.
180
; π = 3.141516
1 Radian =
π
11.- Aplicando el teorema de Taylor a la función Seno se obtiene el siguiente polinomio que equivale
a esa función:
Sen(x) = P(x) =
x x3 x5 x7 x9
−
+
−
+
−"
1! 3! 5! 7! 9 !
12.- Elabore un algoritmo para calcular el seno de un ángulo x usando este polinomio para siete (7)
términos.
13.- Haga un algoritmo que convierta una medida de longitud en kilómetros a metros, centímetros,
milímetros, pulgadas, yardas, millas y pies.
14.- Elabore un algoritmo que convierta una medida de masa en toneladas a kilogramos, quintales,
gramos, libras.
15.- Realice un algoritmo que convierta unidades de fuerza en newtons a dinas.
16.- Elabore un algoritmo que convierta una unidad de presión en pascales a bares.
17.- Haga un algoritmo que calcule el área de una cara de un cubo y su volumen.
Informática I. Versión 1.0 Agosto de 2004.
111
Universidad Autónoma de Occidente
3
18.- Elabore un algoritmo que convierta una unidad de volumen en metros cúbicos m a litros y
centímetros cúbicos.
19.- Lea dos puntos (x, y) y calcule la distancia entre ellos.
20.- Los siguientes son los múltiplos y submúltiplos decimales (ver tabla), elabore un algoritmo que
lea un número dado en unidades y lo muestre en cada uno de sus múltiplos y submúltiplos por
pantalla.
tera
giga
mega
kilo
hecto
deca
unidad
deci
centi
mili
micro
nano
pico
Símbolo
T
G
M
K
H
Da
D
C
M
µ
N
P
Unidades
1.000.000.000.0
1.000.000.000
1.000.000
1.000
100
10
1
0.1
0.01
0.001
0.000.001
0.000.000.001
0.000.000.000.01
21.- Elabore un algoritmo que convierta una medición de tiempo en segundos a horas, minutos y
segundos.
1 hora = 60 minutos
1 minuto = 60 segundos
Ejemplo: sea 34505 la cantidad digitada en segundos se debe mostrar en pantalla
Horas = 9
Minutos = 35
Segundos
= 5
Informática I. Versión 1.0 Agosto de 2004.
112
Universidad Autónoma de Occidente
UNIDAD 6.
SENTENCIAS DE CONTROL EN JAVA
Introducción
Los algoritmos vistos hasta el momento han consistido en simples secuencias de instrucciones; sin
embargo, existen tareas más complejas que no pueden ser resueltas empleando un esquema tan
sencillo, en ocasiones es necesario repetir una misma acción un número determinado de veces o
evaluar una expresión y realizar acciones diferentes en base al resultado de dicha evaluación.
Para resolver estas situaciones existen las denominadas estructuras de control que poseen las
siguientes características:
• Una estructura de control tiene un único punto de entrada y un único punto de salida.
• Una estructura de control se compone de sentencias o de otras estructuras de control.
Tales características permiten desarrollar de forma muy flexible todo tipo de algoritmos aún cuando
sólo existen tres tipos fundamentales de estructuras de control:
• Secuencial.
• Alternativa.
• Repetitiva.
A lo largo de esta lección se presentarán las distintas estructuras de
control, la forma de representarlas en la notación algorítmica y las
correspondientes sentencias FORTRAN para poder utilizarlas en
nuestros programas.
Estructura secuencial
La estructura secuencial es la más sencilla de todas, simplemente indica
al procesador que debe ejecutar de forma consecutiva una lista de
acciones (que pueden ser, a su vez, otras estructuras de control); para
construir una secuencia de acciones basta con escribir cada acción en
una linea diferente. A continuación se muestra una composición secuencial de acciones en notación
algorítmica y su equivalente JAVA.
leer a
leer b
c a+b
escribir c
Dado que las variables numéricas a y b ya estuvieran
declaradas y hayan sido leídas, entonces las dos últimas
instrucciones se escriben así en Java:
c=a+b;
System.out.println( “Valor de c= “ + c ) ;
A continuación, la implementación en Java con su correspondiente salida:
import java.io.* ;
// Importa el paquete de entrada / salida (input / output)
Informática I. Versión 1.0 Agosto de 2004.
113
Universidad Autónoma de Occidente
class EstructuraSecuencial1 {
// Mètodo principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
double a, b, c; // Declaración de las variables reales a, b y c.
// Lectura, vía teclado, de las variables a y b:
System.out.print( "Digite el valor de la variable a: " ) ;
a = Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la variable b: " ) ;
b = Double.parseDouble( br.readLine( ) ) ;
// suma los valores de las variables a y b y lo asigna o
// guarda en la variable c:
c=a+b;
// Muestra el valor de c:
System.out.println( " a + b = " + c ) ;
System.exit( 0 ) ;
// Termine el programa (salir del sistema)
}
// Fin del método main( )
}
// Fin de la clase EstructuraSecuencial1
Existe una forma alternativa de expresar una estructura secuencial escribiendo varias acciones en la
misma línea pero utilizando el punto y coma ( ; ) como separador. Sin embargo, esta última notación
es desaconsejable puesto que puede llegar a hacer el código bastante difícil de leer.
leer a; leer b
c a + b; escribir c
Dado que las variables numéricas a y b ya estuvieran
declaradas y hayan sido leídas, entonces las dos últimas
instrucciones se escriben así en Java:
c = a + b ; System.out.println( “Valor de c= “ + c ) ;
En Java:
import java.io.* ;
// Importa el paquete de entrada / salida (input / output)
class EstructuraSecuencial2 {
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Lectura, vía teclado, de las variables a y b:
System.out.print( "Digite el valor de la variable a: " ) ; double a =
Double.parseDouble( br.readLine( ) ) ;
System.out.print( "Digite el valor de la variable b: " ) ; double b =
Informática I. Versión 1.0 Agosto de 2004.
114
Universidad Autónoma de Occidente
}
Double.parseDouble( br.readLine( ) ) ;
// Calcule c y muéstrelo:
double c = a + b ; System.out.println( " a + b = " + c ) ;
System.exit( 0 ) ;
// Termine el programa (salir del sistema)
}
// Fin del método main( )
// Fin de la clase EstructuraSecuencial2
Por último, es necesario señalar un aspecto importante de la composición secuencial y es que no es
conmutativa.
Estructura alternativa
La estructura alternativa permite bifurcar el “flujo” del programa en función de una expresión lógica;
disponemos de tres estructuras alternativas diferentes: alternativa simple, alternativa doble y
alternativa múltiple.
Estructura alternativa simple
Esta estructura permite evaluar una expresión lógica y en función de dicha evaluación ejecutar una
acción (o composición de acciones) o no ejecutarla; también se la suele denominar SI-ENTONCES. A
continuación se muestra la notación algorítmica y JAVA para la estructura alternativa simple.
si <expresión lógica> entonces
acciones
fin_si
Informática I. Versión 1.0 Agosto de 2004.
En java es:
if ( <expresión lógica> ) {
acciones
}
115
Universidad Autónoma de Occidente
En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo no nulo:
si radio > 0 entonces
longitud = 2 * PI * radio
fin_si
En Java:
if ( radio > 0 ) {
longitud = 2 * Math.PI * radio ;
}
Estructura alternativa doble
La estructura alternativa doble es similar a la
anterior con la salvedad de que en este tipo
de estructura se indican acciones no sólo
para la rama “verdadera” sino también para
la “falsa”; es decir, en caso de que la
expresión lógica evaluada sea cierta se
ejecutan una acción o grupo de acciones y en
el caso de que sea falsa se ejecuta un grupo
diferente de acciones. La sintáxis en la
notación algorítmica y en JAVA son las que
se muestran a continuación:
si <expresión lógica> entonces
acciones
si no
acciones
fin_si
En java es:
if ( <expresión lógica> ) {
acciones
}
else {
acciones
}
En el siguiente ejemplo se calcula la longitud de una circunferencia si el radio es positivo no nulo
y, en caso contrario, se proporciona un mensaje de error:
si radio>0 entonces
longitud = 2·pi·radio
si no
escribir ‘Radio incorrecto’
fin_si
Informática I. Versión 1.0 Agosto de 2004.
116
Universidad Autónoma de Occidente
En Java:
if ( radio > 0 ) {
longitud = 2 * Math.PI * radio ;
}
else {
System.out.println( “Error” ) ;
}
Ejemplo:- Informar si un estudiante ha superado o no un determinado examen consistente en 20
preguntas de igual valor y calcular su nota en caso de aprobar.
leer num_correctas
si num_correctas < 12 entonces
escribir “No ha superado Vd. el examen”
faltan = 12 - num_correctas
escribir “Le faltaron ” , faltan
si_no
nota = num_correctas * 0.25
escribir “aprobó Vd. con un ”, nota
fin_si
En Java:
import java.io.* ;
class AprobarExamen1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
String nombre ;
int numOk, faltan ;
float nota ;
// Entrada de datos:
System.out.print( "Digite su nombre : " ) ;
nombre = br.readLine( ) ;
System.out.print( "Digite el numero de respuestas correctas (1 a 20): " ) ;
numOk = Integer.parseInt( br.readLine( ) ) ;
// Sentencia de decisión if:
// *************************
if( numOk < 12 ) {
System.out.println( nombre + ", Ud. NO ha ganado el examen!!" ) ;
faltan = 12 - numOk ;
System.out.println( "Le faltaron " + faltan +
" respuestas correctas para obtener 3.0 !!" ) ;
}
else {
nota = numOk * 0.25F ;
Informática I. Versión 1.0 Agosto de 2004.
117
Universidad Autónoma de Occidente
System.out.println( nombre + ", Ud. ha ganado el examen con " +
"una nota de " + nota ) ;
}
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase AprobarExamen1
Salida:
Estructura multialternativa
Esta estructura evalúa una expresión que pueda tomar n valores (enteros, caracteres y lógicos pero
nunca reales) y ejecuta una acción o grupo de acciones diferente en función del valor tomado por la
expresión selectora.
La sintaxis de esta estructura es
la siguiente:
segun expresión
caso valor1:
acción 1
caso valor2:
acción 2
...
caso valorN:
acción n
otro caso:
acción
fin según
Informática I. Versión 1.0 Agosto de 2004.
118
Universidad Autónoma de Occidente
La implementación de la estructura multialternativa se escribe así, en Java:
switch( expresión ) { // Llave de apertura del bloque switch
case valor1:
// Acción 1: secuencia de instrucciones
break ;
case valor2:
// Acción 2: secuencia de instrucciones
break ;
…
…
…
case valorN:
// Acción N: secuencia de instrucciones
break ;
default:
// El caso default: es opcional
// Acción: secuencia de instrucciones
break ;
// Aquí, el break ; es opcional, pues es la última del bloque switch
}
// Llave de cierre del bloque switch
En el siguiente ejemplo se proporciona como salida el número de días de un mes dado:
segun mes
caso 1,3,5,7,8,10,12:
escribir ‘31’
caso 4,6,9,11:
escribir ‘30’
caso 2:
escribir ‘28’
otro caso:
escribir ‘Mes incorrecto’
fin según
A continuación, la implementación en Java:
import java.io.* ;
// Importa el paquete de entrada / salida (input / output)
class EstructuraMultialternativa1_switch {
// Método principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int mes ; // Declaración de la variable entera mes
// Lectura, vía teclado, de la variable entera mes
System.out.print( "Digite un numero entero [1 a 12] para el mes: " ) ;
mes = Integer.parseInt( br.readLine( ) ) ;
// Se utilizará una instrucción switch para determinar el número de
// días del mes digitado (número entero de 1 a 12):
Informática I. Versión 1.0 Agosto de 2004.
119
Universidad Autónoma de Occidente
switch( mes ) { // LLave de apertura del switch
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println( "El mes " + mes + " tiene 31 dias." ) ;
break ;
case 4:
case 6:
case 9:
case 11:
System.out.println( "El mes " + mes + " tiene 30 dias." ) ;
break ;
case 2:
System.out.println( "Si el anio NO es bisiesto, el mes " + mes + " tiene 28 dias." ) ;
System.out.println( "Si el anio es bisiesto, el mes " + mes + " tiene 29 dias." ) ;
break ;
default:
System.out.println( "ERROR al digitar el numero para el mes" ) ;
break ;
// Aquí, este break; es opcional.
}
//LLave de cierre del switch
System.exit( 0 ) ;
}
}
// Termine el programa (salir del sistema)
// Fin del método main( )
// Fin de la clase EstructuraSecuencial1
Nota: Obsérvese que es posible que un caso conste de múltiples valores.
Informática I. Versión 1.0 Agosto de 2004.
120
Universidad Autónoma de Occidente
Estructura repetitiva
La estructura repetitiva o iterativa permite, como su propio nombre lo indica, repetir una acción (o
grupo de acciones); dicha repetición puede llevarse a cabo un número prefijado de veces o depender
de la evaluación de una expresión lógica. Existen tres tipos de estructuras repetitivas: desde-hasta (ó
Para), mientras y repetir-hasta.
Estructura desde-hasta (ó Para)
Esta estructura permite repetir la ejecución de una acción o de un grupo de acciones un número
determinado de veces; la sintáxis es la siguiente:
desde indice = inicio hasta fin [con valor de paso] hacer
acción
fin desde
La estructura repetitiva desde-hasta (ó Para) se implementa así, en Java:
for( inicialización; condición; iteración ) {
// Acción: secuencia de instrucciones
}
1. El ciclo (ó bucle) for es controlado por una variable que, por su oficio, también se denomina variable de
control.
2. En su forma más común, la parte de inicialización del ciclo asigna un valor inicial a la variable de control
del ciclo.
3. La condición es una expresión booleana que analiza la variable de control del ciclo. Si el resultado de ese
análisis es true (verdadero), el ciclo for continúa. Si es false (falso), el ciclo termina.
4. La expresión iteración determina cómo cambia el valor de la variable de control del ciclo en cada iteración
del mismo.
A continuación se muestran algunos ejemplos:
Seudocódigo:
desde n 1 hasta 10 hacer
escribir n
fin desde
Código Java:
for( int n = 1; n <= 10; n = n + 1 ) {
System.out.println( “n = “ + n ) ;
}
El ciclo anterior imprime por pantalla los números del 1 al 10.
Ahora, preste atención al siguiente seudocódigo:
desde n 10 hasta 0 hacer
escribir n
Informática I. Versión 1.0 Agosto de 2004.
121
Universidad Autónoma de Occidente
fin desde
que, escrito en código Java, es:
for( int n = 10; n <= 0; n = n + 1 ) {
System.out.println( “n = “ + n ) ;
}
El bucle anterior no se ejecuta nunca puesto que, de entrada, la condición n <= 0 (con n = 10) arroja
false. ¿Qué ocurriría si, en el ciclo anterior, se cambia < por > ? Analice y responda !!
Si queremos hacer lo anterior, por ejemplo con paso – 2, el seudocódigo se puede escribir así:
desde n 10 hasta 0 con paso –2 hacer
escribir n
fin desde
que, escrito en Java, es:
for( int n = 10; n >= 0; n = n - 2 ) {
System.out.println( “n = “ + n ) ;
}
Este bucle escribe los números pares de 10 a 0 en orden inverso.
La siguiente aplicación Java resume estos casos:
class CicloFor1 {
public static void main( String args[ ] ) {
int n ;
// Declara la variable entera n. Ésta,
// será la variable de control del ciclo.
// Ciclo for con paso unitario positivo:
for( n = 1; n <= 10; n = n + 1 ) {
System.out.print( n + ", " ) ;
}
System.out.println( "\n Ahora, el ciclo for con el paso negativo (-2):" ) ;
// Ciclo for con paso negativo (-2):
for( n = 10; n >= 0; n = n - 2 ) {
System.out.print( n + ", " ) ;
}
System.out.println( ) ;
System.exit( 0 ) ;
}
}
Informática I. Versión 1.0 Agosto de 2004.
122
Universidad Autónoma de Occidente
Salida:
Estructura mientras (while)
Esta estructura repite una acción o grupo de acciones
mientras una expresión lógica sea cierta; la sintáxis en la
notación algorítmica y en JAVA es la siguiente:
mientras <expresión lógica> hacer
acción
fin mientras
Así queda en Java:
while( <Condición> ) {
// Acción: conjunto de
// instrucciones que conforman el
// cuerpo del ciclo.
}
Un aspecto muy importante de la presente estructura de control es que si la expresión lógica es
inicialmente falsa el bucle no se ejecuta ni una sola vez; es decir, la estructura mientras supone que el
bucle iterará 0 ó más veces.
A continuación se muestra un ejemplo que solicita al usuario el radio de una circunferencia mientras
el radio introducido sea incorrecto:
mientras radio<0 hacer
escribir ‘Radio?’
leer radio
fin desde
En Java:
import java.io.* ;
// Importa el paquete de entrada / salida (input / output)
class EstructuraMientras1 {
// Método principal:
public static void main( String args[ ] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
double radio ; // Declaración de la variable real radio
// Lectura, vía teclado, de la variable radio:
System.out.print( "Digite el valor del radio (cm): " ) ;
radio = Double.parseDouble( br.readLine( ) ) ;
System.out.println( "Radio antes del ciclo: " + radio ) ;
Informática I. Versión 1.0 Agosto de 2004.
123
Universidad Autónoma de Occidente
System.out.println( "*******************************" ) ;
while( radio < 0 ) {
// LLave de apertura del bloque while
// Lee de nuevo, vía teclado, el radio:
System.out.print( "Digite el valor [ >= 0 ] del radio (cm): " ) ;
radio = Double.parseDouble( br.readLine( ) ) ;
System.out.println( "Radio dentro del ciclo: " + radio ) ;
}
// LLave de cierre del bloque while
}
System.out.println( "*******************************" ) ;
// Muestra el último valor del radio:
System.out.println( "Ultimo valor del radio: " + radio ) ;
System.exit( 0 ) ;
// Termine el programa (salir del sistema)
}
// Fin del método main( )
// Fin de la clase EstructuraMientras1
Notar que mientras radio < 0 el ciclo se ejecuta.
Ahora, note en la siguiente salida, que si desde la primera vez se digita un radio positivo,
entonces el ciclo while no se ejecuta:
Estructura haga-mientras (do-while)
Esta estructura repite una acción o grupo de acciones mientras una expresión lógica sea verdadera.
La sintáxis en la notación algorítmica es la siguiente:
haga
acción
mientras <expresión lógica>
Informática I. Versión 1.0 Agosto de 2004.
Así queda en Java:
do {
// Acción: conjunto de
// instrucciones que conforman el
// cuerpo del ciclo.
} while( <Condición> ) ;
124
Universidad Autónoma de Occidente
Un aspecto muy importante de la presente estructura de control es que la expresión lógica se evalúa al
final; por tanto, el bucle se ejecuta al menos una vez, como una alternativa a la estructura anterior
(while), la cual podría nunca ejecutarse. El siguiente diagrama de flujo ilustra el ciclo haga-mientras:
Punto de entrada
Acción
Verdadero
Expresión
lógica
Falso
Punto de salida
Se aplicará la estructura de control do-while del lenguaje de programación Java, en la
implementación de un sencillo menú:
import java.io.*;
class Menu3 {
public static void main( String args[] ) throws IOException {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
int opcion;
do {
System.out.println( " Opciones del menu:" ) ;
System.out.println( " ******************" ) ;
System.out.println( ) ;
System.out.println( " 1.- Opcion 1" ) ;
System.out.println( " 2.- Opcion 2" ) ;
System.out.println( " 3.- Opcion 3" ) ;
System.out.println( " 4.- Opcion 4" ) ;
System.out.println( " 5.- Terminar" ) ;
System.out.println( ) ;
System.out.print( "\n Ingrese su opcion: " ) ;
Informática I. Versión 1.0 Agosto de 2004.
125
Universidad Autónoma de Occidente
opcion = Integer.parseInt( br.readLine( ) ) ;
} while( opcion < 1 || opcion > 5 ) ;
switch( opcion ) {
case 1:
case 2:
case 3:
case 4:
System.out.println( "\nUsted ha seleccionado la opcion No. " + opcion ) ;
break;
case 5:
System.out.println( "\nUsted ha seleccionado Terminar\n" ) ;
System.exit( 0 );
}
//Fin del switch
}
//Fin del main( )
}//Fin de la clase Menu3
A continuación, la salida:
Informática I. Versión 1.0 Agosto de 2004.
126
Universidad Autónoma de Occidente
Ejercicios Resueltos
Ejercicio 1:- En una playa de estacionamiento cobran $ 2.5 por hora o fracción. Diseñe un
algoritmo que determine cuánto debe pagar un cliente por el estacionamiento de su vehículo,
conociendo el tiempo de estacionamiento en horas y minutos.
Algoritmo 1
INICIO
// Declaración de variables
ENTERO horas, minutos
REAL pago
// Entrada de datos
LEER horas, minutos
// Si hay alguna fracción de hora, incrementa las horas a pagar en una unidad
SI( minutos > 0 )
horas = horas + 1
// Determina el importe a pagar
pago = horas * 2.5
// Salida de resultados
IMPRIMIR pago
FIN
Así queda en Java:
import java.io.* ;
class CobroEstacionamiento1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int horas, minutos ;
float pago ;
// Entrada de datos:
System.out.print( "Digite el numero [entero] de horas: " ) ;
horas = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de minutos [0 a 59]: " ) ;
minutos = Integer.parseInt( br.readLine( ) ) ;
// Si hay alguna fracción de hora, incrementa las horas a
// pagar en una unidad:
if( minutos > 0 ) {
Informática I. Versión 1.0 Agosto de 2004.
127
Universidad Autónoma de Occidente
horas += 1 ;
// Equivalente a: horas = horas + 1 ;
}
// Determina el importe a pagar:
pago = (float) (horas * 2.5) ;
// Promocione a (casting) tipo float
// Salida de resultados:
System.out.println( "Valor a pagar: $" + pago ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase CobroEstacionamiento1
Salida:
Algoritmo 2
INICIO
// Declaración de variables
ENTERO horas, minutos, horasPagar
REAL pago
// Entrada de datos
LEER horas, minutos
// Determina el número de horas a pagar
SI( minutos > 0 )
horasPagar = horas + 1
SINO
horasPagar = horas
// Determina el importe a pagar
pago = horasPagar * 2.5
// Salida de resultados
IMPRIMIR pago
FIN
En Java queda así:
import java.io.* ;
Informática I. Versión 1.0 Agosto de 2004.
128
Universidad Autónoma de Occidente
class CobroEstacionamiento2 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
int horas, minutos, horasPagar ;
float pago ;
// Entrada de datos:
System.out.print( "Digite el numero [entero] de horas: " ) ;
horas = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de minutos [0 a 59]: " ) ;
minutos = Integer.parseInt( br.readLine( ) ) ;
// Determina el número de horas a pagar:
if( minutos > 0 ) {
horasPagar = horas + 1 ;
}
else {
horasPagar = horas ;
}
// Determina el importe a pagar:
pago = (float) (horasPagar * 2.5) ;
// Promocione a (casting) tipo float
// Salida de resultados:
System.out.println( "Valor a pagar: $" + pago ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase CobroEstacionamiento2
Salida:
Informática I. Versión 1.0 Agosto de 2004.
129
Universidad Autónoma de Occidente
Ejercicio 2:- Diseñe un algoritmo que determine si ún número es o no es, par positivo.
Algoritmo
INICIO
// Declaración de variables
REAL numero
CADENA tipoNumero
// Entrada de datos
LEER numero
// Determina si el número es o no es, par positivo
SI( (numero %2 ==0) && (numero > 0) )
tipoNumero = "El número es par positivo"
SINO
tipoNumero = "El número no es par positivo"
// Salida de resultados
IMPRIMIR tipoNumero
FIN
Así queda en Java:
import java.io.* ;
class EsParPositivo1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float numero ;
String tipoNumero ;
// Entrada de datos:
System.out.print( "Digite un numero: " ) ;
numero = Float.parseFloat( br.readLine( ) ) ;
// Determina si el número es o no es, par positivo:
if( (numero %2 ==0) && (numero > 0) ) {
tipoNumero = "El numero es par positivo" ;
}
Informática I. Versión 1.0 Agosto de 2004.
130
Universidad Autónoma de Occidente
else {
tipoNumero = "El numero NO es par positivo" ;
}
// Salida de resultados:
System.out.println( tipoNumero ) ;
System.exit( 0 ) ;
} //Fin del método main( )
}
// Fin de la clase EsParPositivo1
Salida:
Ejercicio 3:- Diseñe un algoritmo que lea tres números y determine el número mayor.
Algoritmo
INICIO
// Declaración de variables
REAL numero1, numero2, numero3, numeroMayor
// Entrada de datos
LEER numero1, numero2, numero3
// Determina el mayor
numeroMayor = numero1
SI( numero2 > numeroMayor )
numeroMayor = numero2
SI( numero3 > numeroMayor )
numeroMayor = numero3
// Salida de resultados
Informática I. Versión 1.0 Agosto de 2004.
131
Universidad Autónoma de Occidente
IMPRIMIR numeroMayor
FIN
Así queda en Java:
import java.io.* ;
class NumMay1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float numero1, numero2, numero3, numeroMayor ;
// Entrada de datos:
System.out.print( "Digite el primer numero: " ) ;
numero1 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el segundo numero: " ) ;
numero2 = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Digite el tercer numero: " ) ;
numero3 = Float.parseFloat( br.readLine( ) ) ;
// Determina el número mayor:
numeroMayor = numero1 ;
if( numero2 > numeroMayor )
numeroMayor = numero2 ;
if( numero3 > numeroMayor )
numeroMayor = numero3 ;
// Salida de resultados:
System.out.println( "Numero mayor = " + numeroMayor ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase NumMay1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
132
Universidad Autónoma de Occidente
Ejercicio 4:- Una tienda ha puesto en oferta la venta al por mayor de cierto producto, ofreciendo
un descuento del 15% por la compra de más de 3 docenas y 10% en caso contrario. Además por
la compra de más de 3 docenas se obsequia una unidad del producto por cada docena en exceso
sobre 3. Diseñe un algoritmo que determine el monto de la compra, el monto del descuento, el
monto a pagar y el número de unidades de obsequio por la compra de cierta cantidad de docenas
del producto.
Algoritmo
INICIO
// Declaración de variables
REAL montopag, montocom, montodes, precio
ENTERO docenas, obsequio
// Entrada de datos
LEER docenas, precio
// Determina el monto de la compra
montocom = docenas * precio
// Determina el monto del descuento y el obsequio
SI( docenas > 3 ) {
montodes = 0.15 * montocom
obsequio = docenas - 3
}
SINO {
montodes = 0.10*montocom
obsequio = 0
}
// Determina el monto a pagar
montopag = montocom - montodes
// Salida de resultados
IMPRIMIR montocom, montodes, montopag, obsequio
FIN
Así queda en Java:
import java.io.* ;
class OfertaDocenasProducto1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
float montopag, montocom, montodes, precio ;
int docenas, obsequio ;
Informática I. Versión 1.0 Agosto de 2004.
133
Universidad Autónoma de Occidente
// Entrada de datos:
System.out.print( "Digite el precio de la docena del producto: $ " ) ;
precio = Float.parseFloat( br.readLine( ) ) ;
System.out.print( "Cuantas docenas del producto has comprado? " ) ;
docenas = Integer.parseInt( br.readLine( ) ) ;
// Determina el monto (ó valor) de la compra:
montocom = docenas * precio ;
// Determina el monto del descuento y el obsequio:
if( docenas > 3 ) {
montodes = 0.15f * montocom ;
obsequio = docenas - 3 ;
}
else {
montodes = 0.10f * montocom ;
obsequio = 0 ;
}
// Determina el monto a pagar
montopag = montocom - montodes ;
// Salida de resultados:
System.out.println( "Valor de la compra: $ " + montocom ) ;
System.out.println( "Valor del descuento: $ " + montodes ) ;
System.out.println( "Neto a pagar: $ " + montopag ) ;
System.out.println( "Por su compra, se le ha obsequiado: " +
obsequio + " docenas." ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase OfertaDocenasProducto1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
134
Universidad Autónoma de Occidente
Ejercicio 5:- Diseñe un algoritmo que lea un número de tres cifras y determine si es o no capicúa.
Un número es capicúa si es igual al revés del número.
Observación
Como el número tiene tres cifras, para ser capicúa basta con que la cifra de las unidades sea igual
a la cifra de las centenas. Por ejemplo: 353, 878, etc.
Algoritmo
INICIO
// Salida de resultados
ENTERO numero, unidades, centenas
CADENA tipoNumero
// Entrada de datos
LEER numero
// Si el número tiene tres cifras...
SI(numero >= 100 && numero <= 999 ){
// Determina la cifra de las unidades y la cifra de las centenas
unidades = numero % 10
centenas = numero / 100
// Determina el tipo de número entre capicúa o no capicúa
SI( unidades == centenas )
tipoNumero = "El número es capicúa"
SINO
tipoNumero = "El número no es capicúa"
// Muestra el tipo de número
IMPRIMIR tipoNumero
}
SINO
IMPRIMIR "Ingrese un número de tres cifras"
FIN
Así queda en Java:
import java.io.* ;
class Capicua1 {
public static void main( String args[ ] ) throws IOException {
Informática I. Versión 1.0 Agosto de 2004.
135
Universidad Autónoma de Occidente
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Como el número tiene tres cifras, para ser capicúa basta con que
// la cifra de las unidades sea igual a la cifra de las centenas.
// Por ejemplo: 353, 878, etc.
// Declaración de variables:
int numero, unidades, centenas ;
String tipoNumero ;
// Entrada de datos:
System.out.print( "Digite un numero entero de tres cifras: " ) ;
numero = Integer.parseInt( br.readLine( ) ) ;
// Si el número tiene tres cifras:
if(numero >= 100 && numero <= 999 ){
// Determina la cifra de las unidades y la cifra de las centenas:
unidades = numero % 10 ;
centenas = numero / 100 ;
// Determina el tipo de número entre capicúa o no capicúa:
if( unidades == centenas )
tipoNumero = "El numero es capicua" ;
else
tipoNumero = "El numero no es capicua" ;
// Muestra el tipo de número
System.out.println( tipoNumero ) ;
}
else
System.out.println( "El numero ingresado debe tener tres cifras!!" ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase Capicua1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
136
Universidad Autónoma de Occidente
Ejercicio 6:- Diseñe un algoritmo que califique el puntaje obtenido en el lanzamiento de tres
dados con base a la cantidad de 6s obtenidos, de acuerdo a lo siguiente: tres seis, excelente; dos
seis, bien; un seis, regular; ningún seis, mal.
Algoritmo
INICIO
// Declaración de variables
ENTERO dado1, dado2, dado3
CADENA calificacion
// Entrada de datos
LEER dado1, dado2, dado3
// Determina la calificación
SI( dado1 + dado2 + dado3 == 18 )
calificacion = "Excelente"
SINO SI( dado1 + dado2 == 12 || dado2 + dado3 == 12 || dado3 + dado1 == 12 )
calificacion = "Bién"
SINO SI( dado1 == 6 || dado2 == 6 || dado3 == 6 )
calificacion = "Regular"
SINO
calificacion = "Mal"
// Salida de resultados
IMPRIMIR calificacion
FIN
Así queda en Java:
import java.io.* ;
class LanzarTresDados1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de variables:
Informática I. Versión 1.0 Agosto de 2004.
137
Universidad Autónoma de Occidente
int dado1, dado2, dado3 ;
String calificacion ;
// Entrada de datos:
System.out.print( "Digite el numero de puntos del primer dado: " ) ;
dado1 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de puntos del segundo dado: " ) ;
dado2 = Integer.parseInt( br.readLine( ) ) ;
System.out.print( "Digite el numero de puntos del tercer dado: " ) ;
dado3 = Integer.parseInt( br.readLine( ) ) ;
// Determina la calificación:
if( dado1 + dado2 + dado3 == 18 )
calificacion = "Excelente" ;
else if( dado1 + dado2 == 12 || dado2 + dado3 == 12 || dado3 + dado1 == 12 )
calificacion = "Bien" ;
else if( dado1 == 6 || dado2 == 6 || dado3 == 6 )
calificacion = "Regular" ;
else
calificacion = "Mal" ;
// Salida de resultados
System.out.println( calificacion ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase LanzarTresDados1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
138
Universidad Autónoma de Occidente
Ejercicio 7:- Una compañía dedicada al alquiler de automóviles cobra un monto fijo de $ 30 para
los primeros 300 km de recorrido. Para más de 300 km y hasta 1000 km, cobra un monto
adicional de $ 0.15 por cada kilómetro en exceso sobre 300. Para más de 1000 km cobra un
monto adicional de $ 0.10 por cada kilómetro en exceso sobre 1000. Los precios ya incluyen el
18% del impuesto general a las ventas, IGV. Diseñe un algoritmo que determine el monto a pagar
por el alquiler de un vehículo y el monto incluído del impuesto.
Algoritmo
INICIO
// Declaración de variables
REAL kilomrec, montopag, montoigv, montofijo = 30, igv = 0.18
// Entrada de datos
LEER kilomrec
// Determina el monto a pagar
SI( kilomrec <= 300 )
montopag = montofijo
SINO SI( kilomrec <= 1000 )
montopag = montofijo + 0.15 * (kilomrec - 300)
SINO
montopag = montofijo + 0.15 * 700 + 0.10 * (kilomrec - 1000)
// Según el enunciado, para determinar el monto del impuesto (montoigv) tenga en
// cuenta que: x + igv * x = montopag, de donde x = montopag / (1 + igv).
// Entonces montoigv = igv * x = igv * montopag / (1 + igv); o sea:
montoigv = igv * montopag / (1 + igv)
// Salida de resultados
IMPRIMIR montopag, montoigv
FIN
Así queda en Java:
import java.io.* ;
class AlquilerAutos1 {
public static void main( String args[ ] ) throws IOException {
// Creación del objeto br de la clase BufferedReader para invocar el
// método readLine( ) que lee datos ingresados vía teclado:
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
// Declaración de dos constantes:
Informática I. Versión 1.0 Agosto de 2004.
139
Universidad Autónoma de Occidente
final double MONTOFIJO = 30, IGV = 0.18 ;
// Declaración de variables:
double kilomrec, montopag, montoigv ;
// Entrada de datos:
System.out.print( "Digite el numero de kilometros recorridos: " ) ;
kilomrec = Double.parseDouble( br.readLine( ) ) ;
// Determina el monto a pagar:
if( kilomrec <= 300 )
montopag = MONTOFIJO ;
else if( kilomrec <= 1000 )
montopag = MONTOFIJO + 0.15 * (kilomrec - 300) ;
else
montopag = MONTOFIJO + 0.15 * 700 + 0.10 * (kilomrec - 1000) ;
// Según el enunciado, para determinar el monto del impuesto (montoigv) tenga en
// cuenta que: x + IGV * x = montopag, de donde x = montopag / (1 + IGV).
// Entonces montoigv = IGV * x = IGV * montopag / (1 + IGV); o sea:
montoigv = IGV * montopag / (1 + IGV) ;
// Salida de resultados
System.out.println( "Valor a pagar: $ " + montopag ) ;
System.out.println( "Por impuesto, Ud. ha pagado $ " + montoigv ) ;
System.exit( 0 ) ;
}
}
//Fin del método main( )
// Fin de la clase AlquilerAutos1
Salida:
Informática I. Versión 1.0 Agosto de 2004.
140
Universidad Autónoma de Occidente
Ejercicio 8:- Diseñe un algoritmo que determine quiénes son contemporáneos entre Juan, Mario
y Pedro.
Algoritmo
INICIO
// Declaración de variables
ENTERO juan, mario, pedro
CADENA contemporaneos
// Entrada de datos
LEER juan, mario, pedro
// Determina quienes son contemporáneos
SI( juan == mario && mario == pedro )
contemporaneos = "Los tres son contemporáneos"
SINO SI( juan == mario )
contemporaneos = "Juan y Mario son contemporáneos"
SINO SI( juan == pedro )
contemporaneos = "Juan y Pedro son contemporáneos"
SINO SI( mario == pedro )
contemporaneos = "Mario y Pedro son contemporáneos"
SINO
contemporaneos = "No hay contemporáneos"
// Salida de resultados
IMPRIMIR contemporaneos
FIN
Ejercicio 9:- El promedio de prácticas de un curso se calcula con base a cuatro prácticas
calificadas de las cuales se elimina la nota menor y se promedian las tres notas más altas. Diseñe
un algoritmo que determine la nota eliminada y el promedio de prácticas de un estudiante.
Algoritmo
INICIO
// Declaración de variables
REAL pc1, pc2, pc3, pc4, pcmenor, promedio
// Entrada de datos
LEER pc1, pc2, pc3, pc4
// Determina la nota menor
pcmenor = pc1
SI( pc2 < pcmenor )
pcmenor = pc2
Informática I. Versión 1.0 Agosto de 2004.
141
Universidad Autónoma de Occidente
SI( pc3 < pcmenor )
pcmenor = pc3
SI( pc4 < pcmenor )
pcmenor = pc4
// Determina el promedio
promedio = (pc1 + pc2 + pc3 + pc4 - pcmenor ) / 3
// Salida de resultados
IMPRIMIR promedio, pcmenor
FIN
Ejercicio 10:- Diseñe un algoritmo que lea tres longitudes y determine si forman o no un
triángulo. Si es un triángulo, determine de qué tipo de triángulo se trata entre: equilátero (si tiene
los tres lados iguales), isósceles (si tiene dos lados iguales) o escaleno (si tiene tres lados
desiguales). Considere que para formar un triángulo se requiere que: "el lado mayor sea menor
que la suma de los otros dos lados".
Algoritmo
INICIO
// Declaración de variables
REAL L1, L2, L3, suma
CADENA tipoRectangulo
L1
// Entrada de datos
LEER L1, L2, L3
L3
L2
// Determina el lado mayor
mayor = L1
SI( L2 > mayor )
mayor = L2
SI( L3 > mayor )
mayor = L3
// Determina la suma de los lados a excepción del lado mayor:
suma = L1 + L2 + L3 - mayor
// Determina de que tipo de triángulo se trata
SI( mayor < suma ){
SI( ( L1 == L2 ) && ( L2 == L3 ) )
tipoRectangulo = "Triángulo equilátero"
SINO SI( ( L1 == L2 ) || ( L2 == L3 ) || ( L3 == L1 ) )
tipoRectangulo = "Triángulo isósceles"
SINO
tipoRectangulo = "Triángulo escaleno"
}
SINO
tipoRectangulo = "No es un triángulo"
// Salida de resultados
IMPRIMIR tipoRectangulo
FIN
Ejercicio 11:- Diseñe un algoritmo que lea tres números enteros y determine el menor valor
positivo. Si los números positivos son iguales, dar como menor a cualquiera de ellos.
Algoritmo
Informática I. Versión 1.0 Agosto de 2004.
142
Universidad Autónoma de Occidente
INICIO
// Declaración de variables
ENTERO a, b, c, menor
// Entrada de datos
LEER a, b, c
// Determina el menor
// ****************
// Aquí a, b y c podrían ser positivos:
SI( a > 0 ){
menor = a
SI( b > 0 && b < menor )
menor = b
SI( c > 0 && c < menor )
menor = c
}
// Aquí sólo b y c podrían ser positivos
SINO SI( b > 0 ){
menor = b
SI( c > 0 && c < menor )
menor = c
}
// Aquí sólo c podrían ser positivos
SINO SI( c > 0 ){
menor = c
}
// Guardamos el indicador -1 para saber que no hay positivos:
SINO
menor = -1
// Salida de resultados
SI( menor != -1 )
IMPRIMIR menor
SINO
IMPRIMIR "No se ingresó ningún número positivo"
FIN
Ejercicio 12:- Diseñe un algoritmo que lea tres números y los imprima de mayor a menor y de
menor a mayor.
Algoritmo
INICIO
// Declaración de variables
REAL n1, n2, n3, mayor, menor, medio
// Entrada de datos
LEER n1, n2, n3
// Determina el menor:
menor = n1
SI( n2 < menor )
menor = n2
SI( n3 < menor )
menor = n3
Informática I. Versión 1.0 Agosto de 2004.
143
Universidad Autónoma de Occidente
// Determina el mayor:
mayor = n1
SI( n2 > mayor )
mayor = n2
SI( n3 > mayor )
mayor = n3
// Determina el medio:
medio = n1+n2+n3-mayor-menor
// Imprime en orden ascendente:
IMPRIMIR menor, medio, mayor
// Imprime en orden descendente
IMPRIMIR mayor, medio, menor:
FIN
Ejercicio 13:- A continuación, se muestra una aplicación Java que solicita números vía teclado y
determina el menor y el mayor de ellos:
import java.io.* ;
class MinMay3A {
public static void main( String args[ ] ) throws IOException {
InputStreamReader isr = new InputStreamReader( System.in ) ;
BufferedReader br = new BufferedReader( isr ) ;
//BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) ) ;
System.out.print( "Digite la cantidad de numeros que va a ingresar: " ) ;
int n = Integer.parseInt( br.readLine( ) ) ;
System.out.println( ) ;
//Deje una línea en blanco.
double num = 0, min = 0, may = 0 ;
for( int k = 1; k <= n; k ++ ) {
System.out.print( "Digite un numero: " ) ;
num = Double.parseDouble( br.readLine( ) ) ;
System.out.println( ) ;
//Deje una línea en blanco.
if( k == 1 ) {
min = num ;
//Que el PRIMER número leído haga de
may = num ; //número menor y de número mayor.
}
if( num < min ) {
min = num ;
}
if( num > may ) {
Informática I. Versión 1.0 Agosto de 2004.
144
Universidad Autónoma de Occidente
may = num ;
}
}
System.out.println( "*****************************************" ) ;
System.out.println( "\nValor minimo: " + min ) ;
System.out.println( ) ;
//Deje una línea en blanco.
System.out.println( "Valor maximo: " + may ) ;
System.out.println( ) ;
//Deje una línea en blanco.
System.exit( 0 ) ;
}
}
Salida:
Ejercicio 14:- Diseñe un algoritmo para obtener el grado de eficiencia de un operario de una
fábrica de tornillos, de acuerdo a las siguientes condiciones que se le imponen para un período de
prueba:
- Menos de 200 tornillos defectuosos.
- Más de 10000 tornillos producidos.
El grado de eficiencia se determina de la siguiente manera:
- Si no cumple niguna de las condiciones, grado 5.
- Si sólo cumple la primera condición, grado 6.
Informática I. Versión 1.0 Agosto de 2004.
145
Universidad Autónoma de Occidente
- Si sólo cumple la segunda condición, grado 7.
- Si cumple las dos condiciones, grado 8.
Entonces, en seudocódigo, Las condiciones impuestas por la fábrica son:
tordef < 200
torpro > 10000
siendo tordef el número de tornillos defectuosos
siendo torpro el número de tornillos producidos
Algoritmo 1
INICIO
// Declaración de variables
ENTERO torpro, tordef, grado
// Entrada de datos
LEER torpro, tordef
// Determina el grado de eficiencia
SI( tordef < 200 ){
SI( torpro > 10000 )
grado = 8
SINO
grado = 6
}
SINO{
SI( torpro > 10000 )
grado = 7
SINO
grado = 5
}
// Salida de resultados
IMPRIMIR grado
FIN
Algoritmo 2
INICIO
// Declaración de variables
ENTERO torpro, tordef, grado
// Entrada de datos
LEER torpro, tordef
// Determina el grado de eficiencia:
SI( tordef < 200 && torpro > 10000 )
grado = 8
SINO SI( tordef < 200 )
grado = 6
SINO SI( torpro > 10000 )
grado = 7
SINO
grado = 5
// Salida de resultados
IMPRIMIR grado
FIN
Informática I. Versión 1.0 Agosto de 2004.
146
Universidad Autónoma de Occidente
Ejercicio 15:- Se cuenta con los votos obtenidos por Juan, Pedro y María en una elección
democrática a la presidencia de un club. Para ganar la elección se debe obtener como mínimo el
50% del total de votos más 1. En caso que no haya un ganador, se repite la elección en una
segunda vuelta, yendo a ésta los dos candidatos que obtengan la más alta votación. Se anula la
elección en caso de producirse un empate doble por el segundo lugar o un empate triple. Diseñe
un algoritmo que determine el resultado de la elección.
Algoritmo
INICIO
// Declaración de variables:
ENTERO vjuan, vpedro, vmaria, vmingan
CADENA resultado
// Entrada de datos:
LEER vjuan, vpedro, vmaria
// Determina la votación mínima para ganar:
vmingan = (vjuan + vpedro + vmaria) / 2 + 1
// Determina el resultado de la elección:
SI( vjuan >= vmingan )
resultado = "Gana Juan"
SINO SI( vpedro >= vmingan )
resultado = "Gana Pedro"
SINO SI( vmaria >= vmingan )
resultado = "Gana María"
SINO SI( vpedro > vjuan && vmaria > vjuan )
resultado = "Pasan a la segunda vuelta Pedro y María"
SINO SI( vpedro > vmaria && vjuan > vmaria )
resultado = "Pasan a la segunda vuelta Pedro y Juan"
SINO SI( vmaria > vpedro && vjuan > vpedro )
resultado = "Pasan a la segunda vuelta María y Juan "
SINO
resultado = "Elección anulada"
// Salida de resultados:
IMPRIMIR resultado
FIN
Ejercicio 16:- Diseñe un algoritmo que lea un número entero de 3 cifras, y forme el mayor
número posible con las cifras del número ingresado. El número formado debe tener el mismo
signo que el número ingresado.
Algoritmo
INICIO
// Declaración de variables:
ENTERO num1, num2, numaux, uni, dec, cen, menor, mayor,medio
// Entrada de datos:
LEER num1
// Si el número tiene tres cifras...
SI( ( num1 >= 100 && num1 <= 999 ) || ( num1 >= -999 && num1 <= -100 ) ){
Informática I. Versión 1.0 Agosto de 2004.
147
Universidad Autónoma de Occidente
// Guarda el número en una variable auxiliar para preservar el signo:
numaux = num1
// Cambia el signo de num1 en caso de ser negativo:
SI( num1 < 0 )
num1 = -num1
// Determina las cifras del número:
cen = num1 / 100
dec = (num1 % 100) / 10
uni = (num1 % 100) % 10
// Determina la cifra menor:
menor = cen
SI( dec < menor )
menor = dec
SI( uni < menor )
menor = uni
// Determina la cifra mayor:
mayor = cen
SI( dec > mayor )
mayor = dec
SI( uni > mayor )
mayor = uni
// Determina la cifra del medio:
medio = cen + dec + uni – mayor - menor
// Forma el nuevo número:
SI( numaux > 0 )
num2 = mayor * 100 + medio * 10 + menor
SINO
num2 = -1 * (menor * 100 + medio * 10 + mayor)
// Imprime el nuevo número:
IMPRIMIR num2
}
SINO
IMPRIMIR "El número no tiene tres cifras"
FIN
Ejercicio 17:- Hallar la suma de N números, a través de una estructura repetitiva
algoritmo suma_números
Entero cantNum, num, auxi
Leer cantNum
auxi = cantNum
SUMA = 0 // la suma parcial es 0 al inicio
MIENTRAS QUE cantNum > 0 HACER
LEER num
SUMA = SUMA+num
Informática I. Versión 1.0 Agosto de 2004.
148
Universidad Autónoma de Occidente
cantNum = cantNum - 1
FIN MIENTRAS
ESCRIBIR “la suma de los” , auxi , “números es “ , SUMA
Ejercicio 18:- Calcular el factorial de un número N, usando la estructura desde-hasta.
Inicio
Entero n, i, fact
leer n
fact = 1
desde i = 1 hasta n hacer
fact = fact * i
fin_desde
escribir “el factorial del número”, n, “es”, fact
Fin
Ejercicio 19:- Calcular los factoriales de n números leídos por el teclado.
El problema consiste en realizar una primera estructura repetitiva de n iteraciones del algoritmo de
cálculo del factorial, que a su vez se efectúa con una segunda estructura repetitiva.
Inicio
Entero n, i, j, num, fact
leer n
// lectura de la cantidad de números
desde i = 1 hasta n hacer
leer num
fact = 1
desde j = 1 hasta num hacer
fact = fact * j
fin_desde
escribir “el factorial del número”, num, “es”, fact
fin_desde
Fin
Ejercicio 20:- Escribir un algoritmo que permita calcular el interés producido por un capital a las
tasas de interés comprendidos en el rango desde 10 a 20 % de 2 en 2 puntos, a partir de un capital
dado. Utilice el ciclo mientras.
Inicio
Entero capital, tasa
Real interes
leer capital
tasa = 10
mientras tasa <= 20 hacer
interes = tasa * 0.01 * capital
// tasa * capital / 100 = tasa * 0.01 * capital
escribir “interés producido”, interes
tasa = tasa + 2
fin_mientras
escribir “Último valor de tasa (fuera del ciclo) = ”, tasa
Fin
Los sucesivos valores de la tasa serán 10, 12, 14, 16,18,20 y 22; de modo que al tomar ‘tasa’ el valor
22, se detendrá el bucle y se escribirá el último valor de tasa. Notar que NO se calculará el interés
para 22, pues este valor hace que la condición sea falsa produciendo la salida y terminación del ciclo.
Informática I. Versión 1.0 Agosto de 2004.
149
Universidad Autónoma de Occidente
Supongamos que ahora nos interesa conocer este dato de 3 en 3 puntos; para ello se cambia la última
línea del bucle por tasa = tasa + 3. Ahora los valores que tomará tasa serán 10, 13, 16, 19 saltando a
22, el cual será el último valor que ocasionará la salida del ciclo y se imprimirá fuera de él.
Ejercicio 21:- Escribir un programa y una función que por medio del paso por valor obtenga el
máximo común divisor de dos números.
// Algoritmo Maximo_comun_divisor
// Programa principal:
Inicio
Entero x, y, m
leer x, y
m = mcd (x, y)
escribir x, y, m
Fin
// Función (en Java se denomina método):
Entero mcd(entero a, entero b)
Inicio
Entero resp
mientras a <> b hacer
si a > b
entonces a = a - b
sino
b=b-a
fin_si
fin_mientras
resp = a
fin
Al ejecutarse este algoritmo se producirán los siguientes resultados:
x
10
y
25
m
5
Informática I. Versión 1.0 Agosto de 2004.
a
10
5
b
25
15
5
mcd
5
150
Universidad Autónoma de Occidente
Ejercicios de Algoritmos de decisión (selectivos):
1. Elabore un algoritmo que lea tres valores diferentes y determine el mayor, el menor y el promedio.
2. Elabore un programa que valide mediante un mensaje si una pareja (x, y) pertenece o no a la
siguiente función: y = 3x - 4.
Ejemplo: la pareja (2,2) sí pertenece a esta función.
3. Diseñe un algoritmo que determine e imprima la hora correspondiente al segundo después de una
hora digitada por el usuario ( hh, mm, ss ).
4. La siguiente ecuación corresponde a la ecuación general de segundo grado en la incógnita X o
ecuación cuadrática
aX2 + bX + c = 0 con a,b y c constantes y a ≠ 0
La formula general para hallar su solución es:
x=
−b ± b 2 − 4ac
2a
A. Elabore un algoritmo para hallar las soluciones reales.
B. Haga la prueba de escritorio para las siguientes ecuaciones.
• X2 - 4X - 5 = 0
• X2 - 4X + 4 = 0
• 4X2 - 8X + 3 = 0
Nota: para efectuar la prueba de escritorio use la siguiente propiedad de las raíces de la ecuación
b
c
y x1 ⋅ x 2 =
de segundo grado: x1 + x 2 = − ;
a
a
5. Modifique el algoritmo de las ecuación general de segundo grado para que calcule las raíces
imaginarias, si existen.
6. Escribir un algoritmo que permita determinar cuál es el ganador de la matricula de honor de entre
4 estudiantes . El algoritmo deberá hallar la nota definitiva de c/u de ellos (4 materias.) Si es
mayor que 4.5 el alumno podrá aspirar a la matricula de honor, de lo contrario no.
7. Diseñe un algoritmo que determine si un año leído por el teclado es o no bisiesto.
Informática I. Versión 1.0 Agosto de 2004.
151
Universidad Autónoma de Occidente
8. Diseñar un algoritmo que permita descomponer un número ( 10 <= x <= 999 ) en sus dígitos e
imprimirlos.
9. Elabore un algoritmo que descomponga un número entero (máximo de tres cifras) en sus dígitos y
luego imprima cada uno de ellos en letras.
10. Diseñe un algoritmo que tome un valor entero positivo (máximo cuatro cifras), lo descomponga y
lo imprima invertido pero como un único número entero.
Ejemplo: sea 3845 el número digitado se debe mostrar en pantalla el número 5483
Nota: para la prueba de escritorio escriba cualquier número de cifras decrecientes en uno como
8765, 6543, 3421, etc. y restele su inverso y vera que siempre dará 3087
11. Escriba un algoritmo para la resolución de una ecuación de primer grado (ax + b = 0).
12. Diseñe un algoritmo que lea una fecha como un número entero de ocho dígitos (ddmmaaaa), y
luego imprima el mes en letras (ejemplo: si se digita el número 02011999 entonces imprime "2 de
enero de 1999.")
13. Lea dos números por teclado y determine si uno es divisor del otro.
14. Se lee un número de máximo tres dígitos (verifique que efectivamente sea de máximo tres dígitos)
y se debe determinar si es un número capicúa, es decir, que leído de izquierda a derecha es igual
que leído de derecha a izquierda. Por ejemplo: 727, 343, etc.
15. Usted debe realizar un algoritmo para un cajero automático, que dispone de billetes de algunas
denominaciones existentes (10000, 20000 y 50000), de forma que se le indique una cantidad a
pagar y determine cuál es la combinación apropiada de billetes para formarla. La cantidad que se
va a retirar debe ser un múltiplo de 10000 y el algoritmo debe chequar que así sea.
16. En una universidad se ha variado el sistema de calificaciones, por tanto se requiere un algoritmo
que indique la valoración en letras cuando se tiene la nota en números, siguiendo la tabla mostrada
a continuación
Nota Numérica Valoración en letras
0.0 – 1.0
P (Pésimo)
1.1 – 2.0
M (Mal)
2.1 – 2.9
R (Regular)
3.0 – 4.0
B (Bien)
4.1 – 5.0
E (Excelente)
17. En una multinacional se cuenta con tres departamentos de ventas, en los cuales los empleados
devengan el mismo salario. Sin embargo se tiene un incentivo de acuerdo al cual, si un
departamento vende más del 50% del total de ventas, se da una bonificación del 20% del salario a
los empleados de ese departamento. Considerando el total de ventas como la suma de las ventas
Informática I. Versión 1.0 Agosto de 2004.
152
Universidad Autónoma de Occidente
de los tres departamentos, indique cuánto devengarán los empleados de cada uno de los tres
departamentos en un mes dado.
18. Realice un algoritmo que indique el valor de la función f(x) para un valor de x determinado por el
usuario. La función ha sido definida de la siguiente forma:
x 2 + 3 x − 10
f ( x) =
x − 5x + 8
x − 3x 2 + 2x
3
x ≤ 10
10 < x < 20
f(x) = 0 para cualquier otro
valor de x.
x > 20
19. En una organización se tiene a los empleados agrupados por categoría, los de categoría 1 ganan
$20.000, los de categoría 2, $15.000, los de categoría 3, $10.000 y los de categoría 4, $7.500. Se
quiere un algoritmo que permita determinar cuanto debe pagarse a un empleado si se conoce el
número de horas que trabajó durante el mes y la categoría a la que pertenece. Se sabe que a todos
se les descuenta un 7.2% por concepto de salud, y si el salario total devengado (mensual) es menos
de 1´000.000, se le da un subsidio del 15% sobre su salario mensual (sin descuentos).
20. Se debe leer un número y determinar en qué categoría se encuentra; se sabe que la categoría A,
son los números entre 0 y 2 inclusive, la categoría B son los números entre 3 y 6 inclusive, la
categoría C, los números 7 y 8, y la categoría D el número 9. (Adivinó, los números validos son
entre 0 y 9).
21. Se quiere determinar el valor de depreciación de un artículo en una empresa, se sabe que el valor
de depreciación anual se determina dividiendo el valor de compra del mismo, entre el número de
años de vida útil; la vida útil se determina de acuerdo a la clase de artículo, los edificios tienen 20
años, la maquinaria, muebles y enseres, 10 años, los vehículos 5 años y los computadores 3.
22. En un concesionario de vehículos, se pagan las comisiones a los vendedores según el valor de la
venta (ver tabla). Al final del mes se desea saber ¿Cuánto ganó un vendedor en total por todas las
comisiones, si se sabe que hizo 4 ventas?
Valor de Venta
Hasta 10.000.000
Más de 10 y Menos de 15
millones
Mas de 15 millones
Comisión para el Vendedor
2%
4%
10%
23. En una empresa comercializadora, cada vendedor debe realizar 5 ventas al mes, por cada venta
ganará una comisión de acuerdo a la tabla de comisiones. Cada vendedor tiene un salario básico
(que usted debe leer) y de acuerdo a la suma del básico y las comisiones, se le genera un
descuento para salud, pensiones y otros como señala la tabla de descuentos. Usted debe imprimir
el código del vendedor, el total de sus ventas, el total ganado por comisiones, el total devengado
(básico + comisiones), el total de descuentos, y el salario a pagar por cada empleado.
Informática I. Versión 1.0 Agosto de 2004.
153
Universidad Autónoma de Occidente
Valor Venta
0-1.000.000
1.000.001-1.500.000
1.500.001 ó más
Comisión
5%
7%
10%
Devengado (salario+comisiones)
0-500.000
500.001-1.000.000
1.000.001 ó más
Descuentos
5%
6%
8%
24. El teniente encargado del planetario desea que se diseñe un algoritmo para que al digitar el
nombre del día indique el astro que dio origen a ese nombre. Recuerde los astros:
Nombre del día
Domingo
Sábado
Viernes
Jueves
Miércoles
Martes
Lunes
Astro
Sol
Saturno
Venus
Júpiter
Mercurio
Marte
Luna
25. Realice el algoritmo para un algoritmo que calcule si un triángulo es isósceles, equilátero o
escaleno dados sus tres lados A, B y C
•
•
•
Isósceles => dos lados iguales
Escaleno => A ≠ B ≠ C
Equilátero => A = B = C
26. Haga un algoritmo que muestre en pantalla si un ángulo es: recto, obtuso o agudo
• Recto = 90°
• Agudo < 90°
• Obtuso > 90°
27. Con relación a sus ángulos un triángulo puede ser:
•
•
•
Rectángulo => Un ángulo recto
Acutángulo => 3 ángulos agudos
Obtusángulo => 1 ángulo obtuso
Elabore un algoritmo que calcule si un triángulo es rectángulo, acutángulo u obtusángulo.
28. Elabore un algoritmo que seleccione personal para un empleo con las siguientes características:
mujeres adultas, solteras y que practiquen algún deporte.
29. Para el cálculo con interés compuesto se utilizan las siguientes fórmulas:
• Hallar una cuota mensual conociendo el interés efectivo mensual (i), número de meses (n),
y el precio del articulo
Informática I. Versión 1.0 Agosto de 2004.
154
Universidad Autónoma de Occidente
Cuota = Precio x
i(1 + i )
n
(1 + i ) n − 1
• Hallar el precio de un articulo conociendo el valor de la cuota mensual, el interés efectivo
mensual (i), y el número de meses (n)
Precio = Cuota x
(1 + i ) n − 1
n
i(1 + i )
• Hallar el valor futuro de una precio actual conociendo el interés efectivo mensual (i), y el
número de meses (n)
Valor Futuro = Precio x (1 + i)n
Elabore un algoritmo que permita de un menú de opciones calcular el valor deseado. (cuota, precio
o valor futuro)
30%
= 0.3
Nota: si i = 30% se debe usar i como: i =
100%
30. Elabore un algoritmo que muestre el dígito que más se repite en un número de 5 cifras, en caso de
no repetirse ninguno imprimir un mensaje que diga "no hay dígitos repetidos".
31. El recargo por trabajar horas nocturnas en una empresa es del 70%, el recargo por trabajar festivos
es del 100%, haga un algoritmo que lea los días laboradas por un empleado, las horas nocturnas el
valor de la hora normal laborada y calcule e imprima el sueldo a pagar junto con el nombre del
empleado.
32. Elabore un algoritmo que tenga cuatro niveles de seguridad para un programa, si el usuario logra
ingresar imprimir el mensaje "Bienvenido", en caso contrario imprimir "Error clave" y el nivel del
error.
33. Realice un algoritmo que lea cuatro números y los muestre ordenados de mayor a menor. Ejemplo:
sean los números 5, 3, 7 y 9, debe mostrar 9, 7, 5 y 3.
34. En un club deportivo se cancela la matricula según sea la categoría del deportista, elabore un
algoritmo que calcule el valor de la matricula si los precios por categoría son:
• Infantil 5-8 años $38.000=
• Juvenil 9-17 años $40.100=
• Adultos mayores a 18 años $45.800=
Se debe hacer un recargo a la matricula del 10% para la liga. Los niños menores a 5 años no
pueden ser matriculados
Informática I. Versión 1.0 Agosto de 2004.
155
Universidad Autónoma de Occidente
35. A los profesores de cierta universidad se les paga por ‘horas cátedra’ dictadas de 45 minutos.
Elabore un algoritmo que lea el número de horas dictadas en un mes, siendo estas horas de 60
minutos, y calcule el pago mensual para el profesor. Tenga en cuenta que a los profesores se les
cancela según la siguiente categoría, donde se indica el precio de la ‘hora cátedra’ :
4
3
2
1
$ 35.400=
$ 29.200=
$ 25.000=
$ 22.500=
Al final al profesor se le resta el 10% de retención en la fuente.
Ejercicios sobre Algoritmos repetitivos (ciclos)
36. Realice un algoritmo que imprima en pantalla el conjunto de los (n) múltiplos de un número
entero (x) digitado por el usuario.
37. Haga un algoritmo que imprima en pantalla el conjunto de los divisores de un número entero (x)
digitado por el usuario.
38. Elabore un algoritmo que calcule el mínimo común múltiplo (m.c.m) de dos números A y B,
recuerde el m.c.m. como su nombre lo indica es el menor múltiplo común de dos o mas números.
Ejemplo: sean los números 8 y 6.
m.c.m. (8, 6) = 24
39. Al divisor común que es mayor que todos los divisores comunes de dos números (A, B) se le
llama máximo común divisor (m.c.d.). Elabore un algoritmo para calcular el m.c.d. de dos
números. Ejemplo: sea 8 y 12 (investigue el algoritmo de Euclides).
m.c.d. (8,12) = 4
Informática I. Versión 1.0 Agosto de 2004.
156
Universidad Autónoma de Occidente
40. Dos números son amigos, si cada uno de ellos es igual a la suma de los divisores del otro.
Ejemplo: 220 y 284 son amigos por que,
284
1
2
4
71
142
Divisores
Suma
220
220
1
2
4
5
10
11
20
22
44
55
110
284
Elabore un algoritmo que calcule si dos número son amigos o no.
41. Elabore un algoritmo que calcule el número de días que existen entre dos fechas. Tenga en cuenta
que existen meses de 30 y 31 días y los años bisiestos.
n
42. Calcular usando cada uno de los tres ciclos el valor de X .
43. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo mientras().
44. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo haga.. mientras().
45. Calcule e imprima las tablas de multiplicar del 1 al 9 usando el ciclo para(.....).
46. Desarrolle un algoritmo que impriman las siguientes series:
1, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44.
1, 4, 9, 16, 25, 36, 49, 64, 81.
2, 4, 6, 8, 10, .....100.
-2, +4, -6, +10, ....100.
47. Elabore un algoritmo que imprima las siguientes series para (n) términos :
a.
1 3 5 7 9
− + − + −"
2 4 6 8 10
c.
1 34 56 7 8 9 10
−
+ −
+
−"
2 4
6
8 10
Informática I. Versión 1.0 Agosto de 2004.
b.
1 3 5 7
9
− + − +
−"
2 ! 4 ! 6! 8! 10!
1 3
5
7
9
d. − − + +
− −"
5 10 15 20 25
157
Universidad Autónoma de Occidente
48. Desarrolle un algoritmo que impriman la suma de los términos de las siguientes series:
Suma = -1 +2 -3 +4 -5, ... hasta N términos.
Suma =+1 +4 -8 +12 +16 -20 +24 +28, -... hasta N términos.
1 1 1
1
Suma = + +
+
+ " hasta N terminos
1 9 25 49
1 1 1
1
Suma = + − + − + " hasta N terminos
1 9 25 49
x 2 x3 x 4
Suma = 1 + x +
+ +
+ " hasta N terminos
2! 3! 4!
Suma = x −
x3 x5 x7
+
−
+ " hasta N terminos
3! 5! 7!
x2 x4 x6
Suma = 1 +
+
+
+ " hasta N terminos
2! 4! 6!
Suma = 1 + x +
x3 x5 x7
xn
+ + +"
3! 5! 7!
n!
Suma = 1 + x +
x2 x3 x4
xn
+ +
+"
(no son exactamente n términos)
2! 3! 4!
n!
(no son exactamente n términos)
49. Escriba un algoritmo que calcule el factorial de un número N. (Ejemplo: el factorial de 4 es igual
a: 1x2x3x4=24)
50. Determine el valor del combinatorio C(m,n), definido como
m!
n !(m − n )!
51. Escriba un algoritmo para calcular si un número es primo o no, recuerde que los números primos
son aquellos que solo son divisibles por la unidad y por ellos mismos: ejemplo 5, 11, 17, etc..
52. Calcular mediante un algoritmo cuantos números primos existen entre 1 y un número M dado por
el usuario.
53. Escriba un algoritmo que muestre el cuadrado de los números del 1 al 50.
Informática I. Versión 1.0 Agosto de 2004.
158
Universidad Autónoma de Occidente
54. Diseñar un algoritmo para determinar la cantidad de mujeres y de hombres que hay en un grupo de
N estudiantes (máximo 45). Además se debe hallar el promedio de edad y de estatura del grupo.
(el usuario digitará para cada integrante del grupo, su sexo, edad y estatura).
de un total de N
aspirantes. Los aspirantes deben cumplir las siguientes condiciones para ser aceptados:
Mayores de edad
Ser ingeniero titulado
Tener experiencia laboral
Al final el algoritmo debe mostrar el total de aspirantes aceptados.
55. Desarrolle un algoritmo que permita seleccionar personal para un empleo
56. Desarrolle un algoritmo que permita calcular el valor de la tangente de un ángulo dado en grados
usando la serie de Taylor del seno y del coseno.
57. Diseñe un algoritmo que calcule e imprima la suma de los números pares e impares comprendidos
entre 1 y 100.
58. Leer N números y calcular el mayor sin importar que se repita.
59. Leer N números y calcular el menor sin importar que se repita.
60. Leer una serie de M números y mostrar al final cuantos son positivos.
61. Calcular la suma de los cuadrados de los números comprendidos entre 1 y N.
62. Leer 10 números y al final imprimir el promedio de estos.
63. Desarrolle un algoritmo que calcule el valor de π usando la siguiente serie:
2 4 4 6 6 8 8 10
⋅"
3 3 5 5 7 7 9 9
π = 4⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ ⋅
El número de términos debe ser dado por el usuario (entre mayor sea el número de términos mayor
será la precisión del cálculo).
64. Se desea calcular la resistencia equivalente en paralelo de un circuito de N resistencias, para lo
cual se le pide que diseñe un algoritmo.
Resistencia equivalente paralelo =
1
1
1
1
+
+ "+
R1 R2 R3
RN
65. Se desea calcular la resistencia equivalente en serie de un circuito de N resistencias, para lo cual se
le pide que diseñe un algoritmo.
Resistencia equivalente serie = R1 + R2 + R3 + " + R N
Informática I. Versión 1.0 Agosto de 2004.
159
Universidad Autónoma de Occidente
66. Implemente un algoritmo que lea un número entero y lo muestre invertido.
67. Calcular y mostrar los N primeros términos de la serie de Leonardo Fibonacci.
Fibonacci = 0,1, 1, 2, 3, 5,...
68. Calcular suma de los primeros 100 términos de la serie de Fibonacci.
69. Elaborar un algoritmo que convierta un número entero positivo, menor a 257 a sistema binario
70. Elabore un algoritmo que permita convertir un número entero positivo (máximo cuatro cifras) en
su equivalente en sistema octal.
71. Escribir un algoritmo que halle el número de años bisiestos en un intervalo dado por el usuario
(año bisiesto – sí es múltiplo de 4, pero sí es múltiplo de 100 deberá ser también múltiplo de 400).
72. Realizar la tabla de multiplicar de x (número digitado por el usuario, puede ser positivo o
negativo), desde 1 hasta n (número digitado por el usuario, puede ser positivo o negativo).
73. Dada la siguiente serie determine el valor de la suma de sus términos. La serie termina cuando
(M-N)2 sea igual a 0, El valor de M debe ser dado por el usuario.
Serie: 1,2,3, (M-0)2,4,5,6,(M-1)2,7,8,9,(M-2)2,.......(M-N)2
74. Dada una fecha (mes, día, año) indicar cuantos días (exactos) han transcurrido desde ese año.
75. En un curso hay 20 alumnos, cada alumno tiene diferente número de notas, se quiere determinar el
promedio de cada estudiante, y el número de estudiantes que perdieron la materia (menos de 3.0).
NOTA: La nota definitiva de un estudiante corresponde al promedio simple de sus notas.
76. Se deben leer números hasta que se digite 99 (el 99 no se debe contar), y determinar cuantos
primos hay, y cuantos pares. (recuerde que estas dos condiciones no son exclusivas).
77. Leer un número en base 10, y determinar su equivalente en cualquier base entre 2 y 16. (Puede
escribir el número al revés en la base indicada)
78. Elabore un algoritmo para que dos personas puedan jugar tres en línea. El ganador es quien
primero logre colocar tres figuras en línea (ver figura). Como ayuda muestre los cuadros
numerados del 1 al 9 a los jugadores para que escojan su jugada.
1 2 3
4 5 6
7 8 9
Informática I. Versión 1.0 Agosto de 2004.
o x o
o x x
x x o
160
Universidad Autónoma de Occidente
79. Que hacen los siguientes algoritmos:
•
ALGORITMO
INICIO
Entero n, i, total
Imprimir "Digite un número entero: "
Leer( n)
Para i = 0 Hasta n
total = total + (2*i)
Fin
Imprimir "El resultado es:" & total
FIN
•
ALGORITMO
INICIO
Real n, h=0, total = 0
Imprimir "Digite un número: "
Leer(n)
mientras h <> n
Imprimir "Digite un número "
Leer (h)
total=total+h
fin
Imprimir"El total es " & total
FIN
80. Elabore un algoritmo que lea cinco notas de (n) números de estudiantes, y que calcule e imprima
el promedio de cada alumno y el promedio del grupo además de la nota del estudiante de mayor y
menor promedio.
81. Un número es perfecto si la suma de sus divisores excepto él mismo es igual al propio número.
Ejemplos:
Número:
Divisores--->
Informática I. Versión 1.0 Agosto de 2004.
6
1
2
3
28
1
2
4
7
14
36
1
2
3
4
6
9
12
18
161
Universidad Autónoma de Occidente
Suma 6
28
55
De lo anterior el 6 y el 28 son números perfectos, el 36 no lo es. Desarrolle un algoritmo que
Calcule si un número es perfecto o no.
82. Elabore un algoritmo que genere un número aleatorio y que les dé la posibilidad a dos jugadores
de adivinar dicho número, el algoritmo debe pedir el número de partidas, intercalar los turnos para
adivinar, mostrar el ganador por partida y el ganador final. El número debe estar entre 0-9. (Use la
función aleatorio.)
83. Elabore un algoritmo que lea las ventas de (n) número de vendedores, para los productos (A, B, C,
D y C), si los precios de los productos son ($1000, $2345, $3876, $1235 y $550) respectivamente,
calcule el número individual y total de productos vendidos, las ventas totales por producto, el
promedio total de ventas, el producto mas vendido, el menos vendido, el vendedor que más ventas
realizó.
84. Realice un algoritmo que calcule la suma de (n) números, el producto de estos y cuantos de estos
son negativos y cuantos positivos. Estos datos deben ser mostrados por pantalla.
85. Haga un algoritmo que lea las notas de (n) estudiantes, que indique el número de estudiantes que
ganaron la materia (mayor o igual a 3.0), el numero de los que la perdieron (menor o igual a 3),
además de indicar cuantos deben habilitar la materia (notas entre 2.5 y menores a 3.0). Todos los
datos deben ser mostrados por pantalla.
86. Realice un algoritmo que lea (n) números y halle el mayor número par, el mayor impar, y el
producto de estos dos números. Estos datos deben ser mostrados por pantalla.
87. Elabore un algoritmo para calcular de (n) números leídos cuantos son primos y cuantos no, y los
mayores de cada grupo.
88. Haga un algoritmo que lea un número entero de 4 cifras (base 10) y que lo convierta a un binario
(base 2) y un octal (base 8). Utilice instrucciones repetitivas (use el operador residuo).
89.
Un profesor necesita calcular las notas finales de su curso, para ello dispone de 7 notas, las
3 primeras componen la nota definitiva de quiz y talleres con un valor de 25%, la 4 nota
corresponde al primer examen parcial con un 25%, la 5 al segundo examen parcial con un 25%,
las dos ultimas (6 examen escrito y 7 trabajo opcional) al examen final con un valor de 25%.
El profesor desea obtener los siguientes resultados para cada estudiante:
• La nota definitiva de quiz y talleres (promedio de las 3 primeras notas)
• La nota definitiva del examen final (en el caso de haber presentado opcional)
• La nota final del estudiante
Estos datos deben ser mostrados en pantalla junto con las demás notas.
Informática I. Versión 1.0 Agosto de 2004.
162
Universidad Autónoma de Occidente
Desea conocer también cuantos aprobaron el curso (notas superiores a 3.0) y cuantos no
cumplieron con los objetivos de este (notas menores a 3.0) y también obtener la mejor nota para
promover este estudiante como monitor de la materia para el próximo semestre. (estos últimos
datos se deben mostrar por pantalla al final del calculo de las notas finales de todo el curso).
90. Elabore un algoritmo que imprima cual es el vendedor del mes de una empresa.
Tabla de Precios
Producto
A
B
C
Precio
$57000
$62000
$83000
Para lograr el cálculo se leen las cantidades de productos vendidos por cada uno de los M
vendedores de la empresa y siguiendo la tabla de precios se determina el mejor como aquel que
mayores ventas haya tenido.
91. Use la siguiente fórmula para calcular la raíz cuadrada de un número entero positivo:
Raíz = 0.5* ( X 1 +
N
)
X1
Donde N es el número del que se desea conocer la raíz y X1 es una variable que se le asigna un
valor inicial de 1.
Con estos dos valores iniciales se obtiene el primer valor de la variable Raíz. Si el valor absoluto
de |Raíz - X1| es mayor a 0.0000001 se le reasignará a X1 el contenido de la variable Raíz y se
hará un nuevo calculo hasta que el valor absoluto sea menor, que es cuando se obtiene el valor
real de la raíz.
92. Escriba un programa que calcule el resultado de la siguiente serie para N términos.
X2 X4 X6
R = 1−
+
−
+"
3!
5!
7!
93. Algunos pueblos de Rusia emplean el siguiente método para multiplicar: escriben los dos factores
uno al lado del otro y se forman con ellos dos columnas: debajo del factor que está a la izquierda
se toma la mitad en números enteros, es decir despreciando fracciones, y de esta mitad se toma la
mitad, y así sucesivamente hasta llegar a 1; debajo del factor que está a la derecha, y
paralelamente, se escribe su duplo, y así sucesivamente hasta emparejar con el ultimo número de
la columna de la izquierda, como puede verse en el ejemplo, se tachan de la columna de la derecha
todos los números colocados enfrente de los número pares de la otra columna y se suman todos los
números no tachados de esta columna; esta suma será el resultado de la multiplicación.
Elabore un algoritmo que emplee este método para multiplicar dos números.
Ejemplo: Multiplicar 22 x 6 = 132
Informática I. Versión 1.0 Agosto de 2004.
163
Universidad Autónoma de Occidente
22
11
5
2
1
Informática I. Versión 1.0 Agosto de 2004.
X
6
12
24
48
96
132
164