1

Algoritmia y programación

Patricia Garzón Fajardo

Actualizado Hugo Alfonso Ortiz Barrero

Fecha de actualización: 17 de junio de 2020 (actualización Docente unidad de software y TIC)

Introducción

Al comenzar el presente Módulo se hará un resumen de lo visto hasta ahora por los
estudiosos para que puedan visualizar la magnitud de lo aprendido hasta ahora
desde el punto de vista de la presente asignatura. Todos los conceptos que se
mostrarán en la primera parte de este módulo son un repaso de temas ya vistos
en las asignaturas de “Lógica de Programación”.

Por otra parte, a través de este Módulo, Algoritmia y Programación, se mostrarán los
elementos que componen los algoritmos teniendo en cuenta la sintaxis en Java y
JavaScript. A si mismo se mostrarán ejemplos de algoritmos implementados en
estos lenguajes de programación con el fin de consolidar los temas aquí vistos.

Al final, se mostrarán ejemplos usando las técnicas de desarrollo de algoritmos

como factor importante en la solución de problemas de mediana complejidad.
Contenido
Introducción................................................................................................... 1
Ideograma .............................................................................................. 5
1. Algoritmia y Programación ..................................................................... 6
1.1. Resumen sobre Algoritmos Una definición práctica ................. 6
Componentes generales de los lenguajes de programación .............. 7
Generación de Código Objeto ............................................................ 8
Construcción de un Algoritmo ............................................................ 8
Características de un Algoritmo ......................................................... 8
1.2. Estructuras Básicas de un Algoritmo ........................................ 9
Identificador ........................................................................................ 9
Tipos de datos .................................................................................... 9
Variables .......................................................................................... 10
Literales ............................................................................................ 10
Constantes ....................................................................................... 11
1.3. Operadores ............................................................................. 11
Operadores Aritméticos .................................................................... 11
Operadores de Relación o Comparación ......................................... 12
Operadores Lógicos ......................................................................... 12
1.4. Estructuras de Control ............................................................ 12
1.5. Métodos de ordenamiento ...................................................... 12
2. Java ....................................................................................................... 15
2.1 Tipos de Datos ........................................................................ 15
2.2 Variables ................................................................................. 16
Consideraciones a tener en cuenta con las variables ...................... 16
Recomendaciones ............................................................................ 17
2.3 Operador de asignación ................................................................. 17
2.4 Operadores aritméticos ........................................................... 18
Orden de precedencia de los operadores aritméticos ...................... 18
Operadores de relación o comparación............................................ 19
2.5 Operadores lógicos y Expresiones lógicas .................................... 20
Orden de precedencia de los operadores aritméticos y lógicos. ...... 21
2.6 Estructuras de Control ................................................................... 22
Estructura de selección IF ................................................................ 23
 Estructura condicional If . . . else ..................................................... 24
If anidados ........................................................................................ 24
Estructura de repetición While.......................................................... 24
Estructura de Repeticion For ............................................................ 26
Estructura de repetición do_while .................................................... 26
2.7 Ejemplo de compilación de un algoritmo implementado en Java ... 28
Mi Primer Programa en Java ............................................................... 32
3. JavaScript ............................................................................................... 35
3.1 Operadores .................................................................................... 35
Operadores de relación o comparación............................................ 36
Ejemplos de operadores de comparación ........................................ 36
Operadores Aritméticos y Unarios. ................................................... 36
Ejemplos de operadores aritméticos y/o unarios: ............................. 37
Operadores Lógicos o Booleanos .................................................... 37
Ejemplo de operadores lógicos: ....................................................... 38
3.2 Estructuras de decisión .................................................................. 38
IF 38
IF … EL SE..................................................................................... 38
Else if................................................................................................ 39
Switch ............................................................................................... 39
3.3 Estructuras de Repetición .............................................................. 40
Ciclo para (for).................................................................................. 40
Ciclo Mientras (While) ...................................................................... 41
Ciclo haga mientras (DO-WHILE)..................................................... 41
Trabajando con Arreglos .................................................................. 42
3.4 Captura de Errores ................................................................. 42
Onerror ............................................................................................. 43
Try … Catch ................................................................................... 43
4. Ejemplos .......................................................................................... 43
4.1 Ejemplos de Java ........................................................................... 44
4.2 Ejemplos JavaScript....................................................................... 45
4.3 Ejemplo de un programa en HTML ................................................ 45
Uso de etiquetas (Tags) <script>, </script>................................................. 46
Atributos de la etiqueta <script> .................................................................. 48
Glosario................................................................................................ 49
Bibliografía ........................................................................................... 50
Ideograma

Tipos de
datos

Variables
Repaso

Operadores
Aritméticos
Java

Estructuras
de control

Ejemplo
Algoritmo
Algoritmia y
programación
Operadores

Estructuras
de decisión

Estructuras
JavaScript
de repetición

Ejemplos Arreglos

Manejo de
errores
 1. Algoritmia y Programación

1.1. Resumen sobre Algoritmos Una definición práctica

Un algoritmo es la solución a un problema, mediante la sucesión de pasos finitos y

organizados de tal manera que provean un resultado eficiente. Podemos ver que
diariamente un ser humano está resolviendo situaciones mediante el uso de los
algoritmos, pero de una manera inconsciente. Miremos lo siguiente:

Figura 1. Ejemplos de algoritmos en un lenguaje natural

Problema: Realizar la suma de los Problema: Cambiar la rueda pinchada de
números un automóvil teniendo un gato mecánico en
2448 y 5746. buen estado, una rueda de reemplazo y una
Inicio llave inglesa.
1. Colocar los números el primero
unidades, decenas, centenas encima del Inicio
segundo, de tal manera que las, etc., de
los números queden alineadas. Trazar una 1. Aflojar los tornillos de la rueda
línea debajo del segundo número. pinchada con la llave inglesa.
2. Empezar por la columna más a la 2. Ubicar el gato mecánico en su
derecha. sitio.
3. Sumar los dígitos de dicha 3. Levantar el gato hasta que la rueda
columna. pinchada pueda girar libremente.
4. Si la suma es mayor a 9 anotar 4. Quitar los tornillos y la rueda pinchada.
un 1 encima de la siguiente columna a la 5. Poner rueda de repuesto y los tornillos.
izquierda y anotar debajo de la línea las 6. Bajar el gato hasta que se pueda
unidades de la suma. Si no es mayor liberar.
anotar la suma debajo de la línea. 7. Sacar el gato de su sitio.
5. Si hay más columnas a la 8. Apretar los tornillos con la llave inglesa.
izquierda, pasar a la siguiente columna a
Fin
la izquierda y volver a 3.
6. El número debajo de la línea es
la
solución.

Fin

En estos ejemplos hay una sucesión de pasos ordenados. Si algunos de los pasos
son alterados puede ser que el resultado no sea el mismo.
Cualquier situación en la vida diaria resulta mediante un algoritmo. Por ejemplo, al
hacer un ponqué, o al encontrar una dirección. La manera de resolver nuestros
problemas cotidianos nos hace la vida más fácil o más difícil. Hay momentos en
nuestras vidas que no resolvemos problemas de la mejor manera, nos complicamos
un poco. Tal vez porque no hemos buscado alternativas para encontrar la mejor
solución a un problema o tal vez no estamos usando nuestra lógica para hacerlo.
Cabe destacar que para resolver un problema siempre hay más de una solución, y
unas son mejores que otras.

Es bueno tener en cuenta que para construir un algoritmo primero que todo hay
que entender muy bien el problema, segundo plantear la solución (primero en
términos generales, posteriormente detallada), tercero codificar el algoritmo en un
lenguaje de programación, cuarto probarlo, y por último ejecutarlo.

Componentes generales de los lenguajes de programación

Programar es el trabajo de escribir un código que sea entendible para la

computadora. Ese código es un conjunto de órdenes escritas en un lenguaje de
programación. Para que ese código (programa) sea interpretado se deben cumplir
unos requerimientos que exige el lenguaje.

Es decir, con relación a la escritura de las sentencias que van a ejecutarse, se

debe hacer uso adecuado de las palabras reservadas del lenguaje y además
cumplir con la sintaxis necesaria. De manera que el programa que se escriba debe
ser analizado en su léxico, sintaxis y semántica (Zhang, 2013).

Hay que resaltar que, la generación del código objeto solo lo hacen aquellos
lenguajes de alto nivel (C, Java, C++, etc.) requiriendo un proceso de compilación.
Este código objeto queda traducido a código binario (0,1) el cual finalmente corre
en la computadora. Si hay un error en la sintaxis, el compilador no genera el código
objeto.

Con el fin de entender aún más el proceso de compilación, en la Figura 6 se

presenta el proceso de la escritura del código fuente (source code) pasando por el
proceso de compilación (compiling) y la generación del código objeto (Binary
Code) el cual es ejecutado (executing).
Generación de Código Objeto

Fuente: Adaptado.de Forouzan y Mosharraf (2008).

Por otra parte, los lenguajes de programación interpretada, como es el caso de

JavaScript, HTML, y PHP, cada línea del programa es analizada en el momento que
se está ejecutando el programa. Si se incurre en un error de sintaxis, este es
mostrado al momento de la ejecución.

Construcción de un Algoritmo

Para la creación de un algoritmo podemos hacerlo mediante un lenguaje natural,

por ejemplo, usando Ingles o Ingles estructurado; aunque como se vio en los
ejemplos anteriores se usó el español. Se recomienda el inglés porque al
implementar este algoritmo en un Lenguajes de programación este proceso es
más rápido.

Igualmente se puede representar un algoritmo gráficamente mediante un diagrama de

flujo.

Características de un Algoritmo

1. Precisión. Es importante el orden de los pasos en que se tiene que ejecutar el

algoritmo.
2. Secuencia. Un proceso va detrás de otro, y esto debe quedar bien definido.
3. Finito. Debe tener un final. Hay que tener cuidado con las estructuras
repetitivas, ya que estas deben terminar cuando se cumpla una condición
especifica.
4. Definido. Debe tener consistencia, cada vez que se ejecute, el resultado
debe ser el mismo. El resultado solo debe variar de acuerdo con los parámetros de
entrada.
5. Efectivo. Los algoritmos deben ser comprobados mediante una prueba de
escritorio para validar que los pasos escritos son coherentes y arrojan el resultado
esperado. Esta actividad debe hacerse antes de entrar a programar el algoritmo
en un lenguaje de programación.
6. General. El algoritmo debe resolver cualquier situación del mismo tipo.
 1.2. Estructuras Básicas de un Algoritmo

1. Datos: Es toda la información que se recibe, procesa, o se calcula dentro

del algoritmo.
2. Instrucciones: Las operaciones que se efectúan sobre los datos.
3. Estructuras de control: Determinan en qué orden se deben ejecutar las
instrucciones

Identificador

Un identificador es el nombre que el programador define para un elemento; dato,

tipo, variable, constante, parámetro, del programa y cuya característica es que es
único.
Dependiendo del lenguaje en particular habrá que cumplir sus requerimientos.
Algunas de las consideraciones a tener en cuenta para la definición del identificador
son:

 Debe empezar por letra

 No usar palabras reservadas del lenguaje de programación
 No empezar por caracteres especiales, etc.

Ejemplo de identificadores en Java:

 estudiante
 primerNombre
 saldo
 cuentaDeAhorro

Un identificador se refiere siempre al mismo elemento, es decir, no se puede utilizar

un identificador para identificar dos o más elementos.

Cada dato definido en el programa es almacenado en el computador en una

única dirección de memoria. Si no se tuviera el identificador para representar esa
localización simbólica, se tendría que conocer y usar la dirección física del dato
para poder manipularlo. En vez de eso, sólo se da el nombre (identificador) y el
compilador es quien determina la ubicación física del elemento al cual se está
haciendo referencia.

Tipos de datos

Un tipo de datos (Data Type) se define como un conjunto de valores y un conjunto

de operaciones que se pueden aplicar sobre esos valores.

El tipo de dato es la forma como se materializa la abstracción de los datos en

un lenguaje de programación. El tipo de dato es una abstracción en la
programación de computadoras, siempre aparece como un componente de otro
elemento concreto en la programación.

Los siguientes tres componentes determinan un tipo de dato:

1. Dominio. Es el conjunto de valores que puede tomar el tipo de datos.

2. Operaciones. El tipo de datos define las operaciones que se pueden aplicar
a los elementos del dominio.
3. Representación. Cada tipo de datos tiene asociado su manera de
representación en bytes en la memoria de la computadora.

Algunos lenguajes (C++, Java) permiten que el programador defina sus propios
tipos de datos, lo cual implica un alto nivel de abstracción. Los tipos de datos
personalizados permiten al programador modelar las propiedades del mundo real
de una forma más precisa. Además de personalizar el tipo de dato, el programador
tiene que definir el dominio, operaciones y representación.

Varios lenguajes definen dos categorías de tipos de datos: simples y compuestos.

1. Tipo simple: es aquel que no puede subdividirse en tipos más simples. Aquí
hay tres categorías: a) Integral (char, byte, short, int, y long), b) Punto flotante: Es
la representación de números con parte decimal y c) Booleano: El tipo de dato
que trata con valores lógicos (verdadero, falso).

2. Tipo compuesto: es un conjunto de elementos en el cual cada elemento es

un tipo
simple. Estos tipos de datos también son conocidos como tipos de datos
estructurados. Entre ellos podemos nombrar: a) Vectores, b) Matrices, y c) Cadena
de caracteres.

Variables

Como su nombre lo indica una variable es un espacio en memoria que guarda un

valor y que puede ser cambiado dentro de la ejecución de un programa. Una
variable tiene asociada un nombre y un tipo de dato. El nombre de una variable no
puede ser una palabra reservada del lenguaje de programación. Por ejemplo, un
nombre de variable puede ser numEst de tipo numérico entero.
Ejemplo de variables en Java String saludo = “Hola mundo”
int ancho = 20

Literales

Son los valores que se le dan a las variables por ejemplo el valor 3.1416 es un
literal asignado a una constante llamada pi. De la misma manera, “programación” es
un literal, un valor dado a la variable asignatura.
Constantes

En programación una constante es como una variable sólo que su valor no cambia y
es contante durante la ejecución del programa. Es decir, se define un identificador al
cual se le da un valor y esto no se va a modificar durante la ejecución.
Ejemplo de constantes:

Pi= 3.1415926

Entrada y Salida de Datos

Toda aplicación informática (conjunto de programas) requiere entrada y salida de

datos. Es decir, leer y escribir en archivos, ya sean estos en Base de Datos o planos.

Cada lenguaje de programación tiene sus propias palabras reservadas para designar
la función de lectura y escritura.

En el caso del lenguaje C la función de lectura se realiza con la función scanf y para
la salida de datos la función es printf.

En el caso del lenguaje Java la función de lectura se realiza con los métodos de la
clase Scanner

Scanner lector = new Scanner(System.in);

int numero = lector.nextInt();

Y la salida de datos por pantalla con el método print o println

System.out.println (“El número leído es ” + numero);

1.3. Operadores

Los operadores más familiares son tomados de las matemáticas y esencialmente

pueden ser de tres tipos: aritméticos, relacionales, y lógicos.

Operadores Aritméticos
Básicamente hay 5 operadores aritméticos. Ellos son: Suma +
Resta -
Multiplicación *
Cociente /
Modulo %
Operadores de Relación o Comparación
Básicamente hay 6 operadores de relación o comparación. Ellos son: Igual a ==
Diferente a !=
Menor a <
Menor a o igual a <=
Mayor a >
Mayor a o igual a >=

Operadores Lógicos
Son tres los conectores lógicos que perteneces a esta categoría: Conector lógico “O”
||
Conector lógico “Y” &&
Negación “NO” !

1.4. Estructuras de Control

1. Secuencial. No cambian el flujo del programa. Por ejemplo, a=a+1.

2. De selección. Envía el control del programa de acuerdo a una condición
denotada con si (IF) o sino (ELSE).
a. Si (if)
b. Si_sino (if_else)
c. Sino_si (else_if)
3. De repetición. Repite una secuencia de instrucciones tantas veces como se
indique mediante el uso de un WHILE o FOR.
a. Ciclo para (for)
b. Ciclo haga hasta (while)
c. Ciclo haga mientras (do_while)

1.5. Métodos de ordenamiento

Existen tres métodos que son selección, inserción, y burbuja. Es importante conocer
estos algoritmos porque ellos pueden ser utilizados de acuerdo a la cantidad de
datos que se quieran ordenar, ya que de esto depende la eficiencia de los mismos.

1. Selección: Para hacer el ordenamiento hace comparaciones sucesivas, el

primer elemento con el resto de la lista y al encontrar el menor hace intercambio de
posiciones con el valor encontrado. Posteriormente compara el segundo con el resto
de la lista hasta encontrar el menor y hace intercambio. Este proceso lo repite
hasta llegar al último elemento de la lista. Su algoritmo se puede ver en la figura 2.
2. Inserción. Empieza a hacer el ordenamiento considerando que el primer
elemento está ordenado. (Este es puesto como el primer elemento en una sub-
lista). Posteriormente el segundo elemento de la lista inicial se compara con el primer
elemento de la sub-lista, si es menor al primero de la sub-lista se inserta antes, sino
se inserta después. Ahora, se continúa con el tercer elemento de la lista inicial
comparándolo con el segundo elemento de la sub-lista, si es menor se inserta
antes, sino se inserta después. Y así sucesivamente hasta llegar al último
elemento de la lista inicial. Al final tenemos todos los valores ordenados en la sub-
lista. Este ordenamiento se efectúa usualmente como un ser humano lleva a cabo
esta tarea.
3. Burbuja. El ordenamiento de burbujas empieza a hacer comparaciones por
parejas desplazándose hasta la izquierda hasta llegar a la última posición donde se
deja el elemento más grande, en caso de una ordenación ascendente. La segunda
iteración se hará lo mismo, pero llegando hasta el antepenúltimo elemento y así
sucesivamente hasta que solo quede un elemento en la lista, eso quiere decir que
la lista ya está ordenada. Ver figura 2.
Figura 2. Algoritmos de Ordenamiento
Ordenamiento por Seleccion Ordenamiento de Burbuja

Con el fin de afianzar los conocimientos, se recomienda fijar su atención en la

figura 3 donde se muestra el mapa conceptual de los elementos asociados a un
algoritmo.
Figura 3. Elementos relacionados con un algoritmo
Mapa Conceptual de un algoritmo

While
if
For
Saludo=”hola
mundo”
Pi=3.1416
Son repetitivas es condicional
ejemplo
Aritmeticos
Ej:+,-,*,/,//
Variables Estructuras de
Literales Relacionales
Control
Contantes <.>,=,>+,<=

tiene Deben escribirse de Operadores

Esta compuesto de acuerdo a una sintaxis
especifica tienen
Booleanos
Ej. Y, o, no
Preciso
Secuencial Debe ser Algoritmo ejecuta Sentencias
Finito

asigna
son

toma Son de
Genera

Tipos de Datos
compuestas
Datos de asignacion
son son
entrada Datos de
salida
simples compuestos
Por ejemplo Por ejemplo
Saldo=78000;
Retiro=10000;
son Saldo=78000 Nuevo_saldo=saldo-
Tales como Valor del area de
retiro;
la circunsferencia
El radio de la
circunferenccia
Vectores
E
Matrices
n
Cadena
t de
caracteres
e
r
o Fuente: Autoria propia
s

D
e
c
i
m
a
l
e
s

B
o
o
l
e
a
n
o

A
l
f
a
b
e
t
i
c
o
s
 15
2. Java

El presente módulo se encarga de la conceptualización sobre los fundamentos

esenciales del lenguaje de programación Java, dejando los estudiosos con las
habilidades para iniciar su camino hacia el desarrollo de algoritmos mediante su
codificación en el lenguaje de programación mencionado anteriormente.

El objetivo del presente módulo es llevar al estudioso a construir un algoritmo y

probarlo, para ello requiere pasar el algoritmo a Java, por lo tanto, iniciamos el
módulo presentando los elementos necesarios en Java para cumplir con este
propósito.

La profundidad de los conceptos en Java que se presentan es la necesaria con el fin

de escribir un código claro y funcional. Igualmente se presenta la integración entre
el problema planteado, el algoritmo representado en un diagrama de flujo y su
codificación en Java.
2.1 Tipos de Datos

A continuación, presentamos los tipos de datos con un buen nivel de profundidad y

enfocados a su definición en Java.

Recuerde que: en Java, todo valor tiene un tipo (type). Por ejemplo, el número 13
tiene el tipo int (abreviación de integer, entero). “Hola Mundo” tiene tipo String y el
objeto System.out tiene el tipo PrintStream. El tipo de dato dice qué operación se va
llevar a cabo con esos valores. Por ejemplo, se puede calcular la suma o
multiplicación de dos enteros o se puede invocar el método println sobre cualquier
objeto de tipo PrintStream.

En la Tabla 1 se presenta un resumen de los tipos primitivos en Java con su

respectiva palabra reservada, tamaño, valor mínimo y valor máximo. Igualmente, se
puede apreciar que Java tiene separado los tipos para números enteros y de punto
flotante.

Como bien se sabe un entero es un número sin decimales, por el contrario, un

número de tipo flotante es un número con parte decimal.

Tabla 1. Tipos primitivos en Java

Fuente: Tomado de Friesen (2011, p.17)

Con el fin de procesar números con parte decimal se debe utilizar el tipo “double”, lo
que en la tabla anterior aparece como número de punto flotante con doble
precisión.
 16
Cabe destacar que en Java los números no son objetos y no tienen métodos. Sin
embargo, pueden combinar variables, literales, operadores y/o métodos generando
con todos ellos una expresión como (x + y) * 2

Un tipo de dato primitivo y fundamental en los lenguajes de programación es el

tipo Boolean (Lógico). Es decir sus únicos valores son True o False (verdadero o
falso). El propósito de este tipo de dato es manipular expresiones lógicas. Una
expresión que se evalúa para determinar si es verdadera o falsa es una expresión
lógica.
Recuerde que en Java boolean, true, y false son palabras reservadas; por lo
tanto, no se pueden usar para definir variables.

2.2 Variables

Las variables son definidas en un programa con el fin de usarlas posteriormente

como áreas de trabajo. Estas variables son almacenadas en memoria y pueden
ser invocadas y modificadas durante la ejecución de un programa. Veamos su
sintaxis en Java:

Sintaxis typeName variableName = value; o typeName variableName;

Recuerde que: una variable tiene asociado un tipo (entero, punto flotante, etc),
nombre y contenido.

Analicemos el siguiente ejemplo:

String saludo = “Hola Mundo”;

PrintStream printer =
System.out; Int ancho = 20;

A la primera variable se le dió el nombre de “saludo” y se definió como tipo “string”

por lo que puede almacenar un valor como “Hola Mundo”. La segunda variable
“printer” almacena un valor PrintStream y la tercera “ancho” es del tipo entero y
almacena el valor 20.

Las variables se pueden usar en lugar del valor que ellas almacenan, es decir:

En lugar de escribir System.out.println (“Hola Mundo”) se puede escribir

printer.println (saludo);

En lugar de escribir System.out.println(20) se puede usar printer.println

(ancho);

Consideraciones a tener en cuenta con las variables

No puede usar una variable tipo carácter (String) para almacenar un entero. El
compilador verifica esta falta de coincidencia en los tipos para evitar errores en el
momento de ejecución.

Cuando asigne el nombre a una variable debe escoger un nombre que de

significado al propósito de dicha variable, use nombres nemotécnicos.

Un identificador (identifier) es el nombre de una variable, objeto o clase. Java

tiene las siguientes reglas para nombrar identificadores:

 El identificador puede estar construido de letras, dígitos, raya al piso ( _ ) y

signo pesos ($). No puede comenzar con un dígito.
 No p u e d e usar espacios o símbolos como el signo de interrogación (?) o el
 17
signo de porcentaje (%).
 No puede usar palabras reservadas de Java como ejemplo: public, For .
 Variables y métodos deben comenzar con una letra minúscula. Está bien
usar mayúsculas como en este ejemplo primerApellido. Esta mezcla de
usar letras minúsculas y mayúsculas se conoce como “camel case”
haciendo referencia a las jorobas del camello.
 Los nombres de las clases deben comenzar con letra mayúscula. Por
ejemplo, Saludo es un nombre apropiado para una clase, pero no para una
variable.
 No puede usar el símbolo $ en nombres. Está destinado para el uso de las
herramientas como el compilador y sistema operativo.

Es muy importante todas las anteriores consideraciones ya que algunas no son

aceptadas al momento de la compilación y las otras si no son utilizadas no dan
claridad a la escritura del programa lo que hace difícil el mantenimiento
posteriormente.

Recomendaciones
Escoja nombres descriptivos para las variables. En algebra usualmente se usa
variables como p,x,y. Es fácil caer en la tentación de usar estos nombres para
definir variables, pero antes considere lo siguiente:

int A = a * h;
compare con la siguiente instrucción
int Area = ancho * alto;

Observando el anterior ejemplo las ventajas saltan a la vista, usando nemotécnicos

hace más fácil el entendimiento del código. La palabra “área” expresa exactamente
cuál es la operación por efectuarse. Por el contrario, la letra “A” es un dato que por
sí solo no dice nada.

En la programación práctica de sistemas de información, las variables descriptivas

son particularmente importantes cuando los programas son escritos por un grupo de
programadores y modificados posteriormente por otro grupo.

Recuerde que: en Java una variable tiene que ser previamente definida antes de
ser usada, de otra manera Java envía un error al momento de compilación.

2.3 Operador de asignación

El signo igual (=) es el que se utiliza como operador de asignación en Java, este
siempre es utilizado para asignar valores a variables o constantes. Por ejemplo:

int ancho = 10;

string saludo = “Hola Mundo”;

Una vez definidas las variables, sus valores también pueden ser cambiados
posteriormente, pero recuerde que deben ser variables del mismo tipo. En el caso
anterior a la variable “ancho” siempre se le va a asignar un valor entero. Así
mismo a la variable “saludo” siempre se le va a asignar una cadena de caracteres.

Java genera un error al usar una variable que no ha tenido un valor previamente
asignado, por ejemplo:

int alto;
ancho = alto; // ERROR porque no ha inicializado previamente la
variable alto.
 18
Continuando con el ejemplo, podemos ver lo siguiente:

int alto = 30;

ancho = alto; // Asignación hecha correctamente

Inclusive, puede hacer lo siguiente:

int alto =
30; int
ancho =
alto;

Ahora bien, el lado derecho del símbolo = puede ser una expresión matemática,
así:
ancho = alto + 10;

Esto significa “calcule el valor de alto + 10 y almacene ese valor en la variable

ancho”.
2.4 Operadores aritméticos
Java tiene cinco operadores aritméticos: Suma +
Resta -
Multiplicación *
División /
Módulo %

A continuación, se muestran algunas expresiones que usan algunos de los

operadores aritméticos:

En esta expresión 1, el operador – (resta) se

usa para
-5
especificar que el número 5 es negativo.
Igualmente cabe destacar que es un operador
unario porque solamente tiene un operando.
En la expresión 2, el símbolo – se usa para
restar 7
8–7
de 8. En esta expresión, - tiene dos operandos,
8 y 7. Operadores que tienen dos operandos
se llaman operadores binarios.
x y y tienen valores desconocidos.
Formalmente, una
expresión aritmética se construye con
x+2*5+6/y
operadores aritméticos y números. Los
números y los símbolos alfabéticos se llaman
operandos. Los números y símbolos
alfabéticos usados para evaluar un operador se
llaman operandos para ese operador.

Es importante destacar que: los operadores de suma (+) y resta (-) pueden ser
operadores unarios o binarios. Por otra parte, los operadores aritméticos como la
multiplicación (*), división (/), y modulo (%) son estrictamente binarios por lo que
deben tener dos operandos.

Orden de precedencia de los operadores aritméticos

Cuando en una expresión se usa más de un operador aritmético, Java usa las
reglas de precedencia para determinar el orden en el cual las operaciones serán
 19
ejecutadas para determinar el valor de la expresión. El orden de precedencia de los
operadores aritméticos es:

Primero, la multiplicación (*), la división (/), y el modulo (%) Segundo, la suma (+) y la
resta (-)

Observe que la multiplicación, división y modulo tienen el mismo nivel de

precedencia. De la misma manera pasa con la suma y la resta.

Cuando en una expresión aritmética aparecen varios operadores aritméticos con el

mismo nivel de precedencia la expresión es evaluada de izquierda a derecha. Con
el fin de evitar confusión se recomienda el uso de paréntesis para agrupar los
operandos con su respectivo operador(es).
2.4.1.1 Ejemplo usando el orden de precedencia:

3*7-6+2*5/4+6

Significa lo siguiente:

(((3 * 7) - 6) + ((2 * 5) / 4 )) + 6
= ((21 - 6) + (10 / 4)) + 6 (Evalúa *)
= ((21 - 6) + 2) + 6 (Evalúa /, observe que es una división de enteros)
= (15 + 2) + 6 (Evalúa -)
= 17 + 6 (Evalúa primero +)
= 23 (Evalúa +)

Operadores de relación o comparación

Para tomar decisiones, se debe estar en capacidad de expresar condiciones y

hacer comparaciones. Por ejemplo, en una cuenta corriente si se sobregira deberá
pagar intereses por sobregiro (es una condición). De la misma manera una cuenta de
ahorros debe tener un saldo mínimo (es una comparación) para que le paguen
intereses de rendimiento sobre el saldo (es una condición).

Una expresión que tiene un valor de verdadero o falso se llama expresión lógica
(Boolean). Los valores verdadero o falso (True, False) se llaman valores lógicos.
Suponga que i y j son enteros, en la siguiente expresión lógica:

i>j

La anterior expresión tendrá el valor verdadero solo si la condición se cumple, o

sea cuando i es mayor que j. El símbolo > es llamado operador relacional
porque el valor de i > j es verdadero sólo cuando la relación “mayor que” la tenga i
con relación a j.

De manera que un operador relacional le permite hacer comparaciones en un

programa. Java tiene seis operadores de relación los cuales se presentan en la
Tabla 2 como se puede ver a continuación:
 20
Tabla 2. Operadores de relación en Java

Fuente: Tomado de Malik (2010, p.168)

2.5 Operadores lógicos y Expresiones lógicas

A continuación, se presenta la manera de cómo formar y evaluar expresiones

lógicas que son combinaciones de otras expresiones lógicas. Los operadores
lógicos son los que permiten la combinación de expresiones lógicas. Java tiene
tres operadores lógicos que se presentan en la Tabla 3.

Tabla 3. Operadores Lógicos en Java

Fuente: Tomado de Malik (2010, p.172)

Los operadores lógicos manejan solamente operandos que implican lógica y

producen como resultado solamente valores lógicos. El operador ! es unario, sólo
tiene un operando. Los operadores && y || son binarios.

En la siguiente tabla (Tabla 4), se indica el uso del operador !, !True es falso y
!False es verdadero. Colocando ! al frente de una expresión lógica invierte el
valor de esa expresión lógica.

Tabla 4. Tabla de verdad para el operador !

Fuente: Tomado de Malik (2010, p.172)

Ejemplo. !(6 <= 7) su valor es Falso. Porque 6 es <= 7 luego es Verdadero, pero el
signo (!) invierte el valor.

Ahora vamos a analizar el operador && (Y). En la Tabla 5 se resume la tabla de la

verdad de este operador. La expresión 1 && expresión 2 es Verdadera, si y sólo si
expresión 1 y expresión 2 son verdaderas de lo contrario expresión 1 y expresión 2
se evalúan como Falso.
 21
Tabla 5. Tabla de verdad del Operador "y"

Fuente: Tomado de Malik (2010, p.173)

A continuación, vemos el operador || (O). En la Tabla 6 se resume la tabla de la

verdad de este operador. La expresión 1 || expresión 2 es verdadera sólo si una de
las dos expresiones es verdadera de lo contrario es falsa.

Tabla 6. Tabla de la verdad para el operador "O"

Fuente: Tomado de Malik (2010, p.173)

Orden de precedencia de los operadores aritméticos y lógicos.

Para trabajar con expresiones lógicas complejas, se requiere de un esquema que

priorice para poder determinar cuál operador se evalúa primero. Dado que una
expresión puede contener operadores aritméticos, de relación, lógicos como la
que se presenta a continuación 5 + 3 <= 9 && 2 > 3, se requiere un orden para
establecer su valor.

En la Tabla 7 se presentan los operadores típicos de Java con su correspondiente

precedencia de la más alta a la más baja.

Recuerde que: existen 5 operadores aritméticos, 6 operadores de relación y 3

operadores lógicos.

Tabla 7. Precedencia de Operadores

Fuente: Tomado de Malik (2010, p.174)

 22

Haciendo uso de las reglas expuestas en tabla No.7, en una expresión los
operadores de relación y lógicos son evaluados de izquierda a derecha. En
consecuencia, la asociatividad de estos operadores se dice que va de izquierda a
derecha. Se puede insertar paréntesis en la expresión con el fin de facilitar la
lectura de la expresión o modificar su orden de evaluación.

Al evaluar la siguiente expresión da como resultado “falso”: (17 < 4 * 3 + 5) || (8 * 2 ==

4 * 4) && !(3 + 3 == 6)
La anterior expresión es falsa, por cuanto:

= (17 < 12 + 5) || (16 == 16) && !(6 == 6)

= (17 < 17) || Verdadero && !(Verdadero)
= Falso || Verdadero && Falso
= Falso || Falso (porque verdadero && Falso es Falso)
= Falso

También se puede usar paréntesis para anular la precedencia de los operadores.

Veamos la siguiente expresión:

(7 >= 8 || 'A' < 'B') && 5 * 4 == 20

Se evalúa primero el operador || que el operador &&; mientras que en la expresión:

7 >= 8 || 'A' < 'B' && 5 * 4 == 20

Se evalúa primero el operador && que el operador ||.

2.6 Estructuras de Control

Las estructuras de control brindan alternativas para el desarrollo secuencial en la

ejecución del programa y se usan para alterar el flujo del mismo. En la Figura 4 se
pueden ver los diagramas de flujo de estas tres estructuras y posteriormente se
hace una breve descripción de cada una de ellas.

Figura 4. Estructuras de flujo de ejecución

Fuente: Tomado de Malik (2010, p.166)

 Secuencia. Ejecuta una instrucción detrás de la otra.

 Selección. También se conoce como bifurcación. Permite enviar el flujo del
programa a hacer otras instrucciones de acuerdo a ciertas condiciones. Las
estructuras que pertenecen a esta categoría son if e if..else.
 Repetición. Ejecuta instrucciones repetitivamente hasta que una condición dada
no se cumpla. Estas estructuras son llamadas bucles o loops (En Inglés).
Dentro de la presente categoría se encuentran las estructuras como for, while y
 23
do_while.
Las dos estructuras más comunes son la de selección o decisión y repetición. En la
decisión el programa ejecuta uno u otro conjunto de instrucciones dependiendo del
resultado verdadero o falso de la expresión lógica. Por otra parte, en la
repetición el programa ejecuta un conjunto de instrucciones un determinado número
de veces dependiendo de la evaluación de una expresión lógica o condición.

Veamos un acercamiento al concepto de la estructura de decisión. Veamos las

siguientes declaraciones que no corresponden todavía a instrucciones de Java. En
Java el condicional se codifica con la palabra reservada IF, en nuestro caso para
hacer una pseudo-codificación lo escribimos como Si.

Si (marcador es mayor o igual a 90) grado es A

En la anterior expresión se incluye una condición “marcador es mayor o igual a

90”. La sentencia “grado es A” solo es ejecutada si la condición se cumple, esto es
cuando el marcador sea 90 o mayor. Veamos otro ejemplo:

. Si (temperatura es mayor a 18o Celsius y no está lloviendo) Se recomienda jugar

fútbol

En ciertas situaciones la verdad de una expresión depende de más de una condición.

Para el caso anterior ambas expresiones, “temperatura es mayor a 18º Celcius”, y
“no está lloviendo” deben cumplirse, o sea deben ser verdaderas (true) para que se
lleve a cabo la sentencia “se recomienda jugar fútbol”.

Estructura de selección IF

En la Figura 3 se puede ver el diagrama de flujo para la estructura IF; ahí se

muestra que solo si la condición se cumple se ejecuta una sentencia. Si la condición
no se cumple no sucede nada.

Figura 5. Estructura de Selección IF

Fuente: Tomado de Malik (2010, p.188)

A continuación, se puede ver la sintaxis para escribir este tipo de estructura en

Java.

If (condición) {
sentencia;
}

Ejemplo estructura condicional if:

Un banco necesita enviarles una nota a los clientes cuando el saldo en su cuenta
 24
este en rojo o por debajo del saldo mínimo requerido. Suponemos que el saldo
mínimo es 1000. A continuación, la solución:

If (saldo < 1000)

enviar mensaje;

Estructura condicional If . . . else

En la Figura 6 se representa la estructura if . . . else mediante un diagrama de

flujo. Se puede ver que la condición if, tiene dos opciones de acuerdo a la condición.
La primera es que si la condición se cumple se efectúa la sentencia1, por otro lado
si la condición no se cumple se efectúa la sentencia2.

Figura 6. Estructura if....else

Fuente: Tomado de Malik (2010, p.183)

If anidados

Es posible tener que construir un conjunto de if secuenciales con el fin de establecer

la debida lógica que los requerimientos imponen. Veamos un ejemplo al respecto.

If (saldo > = 50000) tasaInteres = 0.05;

else
if (saldo > = 25000) tasaInteres = 0.03;
else
if (saldo > = 1000) tasaInteres = 0.01;
else
tasaInteres = 0.00;

En el anterior ejemplo se puede ver que hay varios if, uno anidado dentro del otro.
Vemos que si la primera condición “saldo >= 50000” no se cumple, se genera otro if
“saldo>=25000”, si este no se cumple, se genera otro if “saldo>=1000” y solo para
esta última condición se procesan dos acciones diferentes.
Estructura de repetición While

Esta estructura while repite las instrucciones especificadas en una sentencia

(statement) tantas veces sea necesario hasta que se cumpla la condición dada en el
ciclo while. En la Figura 7 muestra el diagrama de flujo de la estructura while.
 25
Figura 7. Diagrama de flujo de la estructura while

Fuente: Tomado de Malik (2010, p.288)

Esta estructura de repetición tiene la siguiente sintaxis:

While (condición)
Statement

La condición es una expresión lógica y es el punto de entrada a la estructura

while. Debe ser verdadera para que se ejecute el cuerpo (statement) del bucle
(loop). Luego la condición es nuevamente evaluada si es verdadera se vuelve a
ejecutar el cuerpo del ciclo (statement) hasta cuando ya no sea más verdadera la
condición. Un ciclo que continúa su ejecución sin finalizar se llama ciclo infinito.
Para evitar esto debe escribir una instrucción dentro del cuerpo de ciclo que le
garantice que la condición se evalúe como falsa.
Ejemplo de la estructura de repetición while:

int i = 0; // línea 1
while (i <= 20) { // línea 2
System.out.println ( i + “ “); // línea 3
i= i + 5; // línea 4
}

La ejecución arroja los siguientes resultados: 0, 5, 10, 15, 20.

En la línea 1 la variable i se inicializa a 0. En la línea 2 se evalúa la condición i <= 20

cuyo valor es verdadero, por lo tanto, se entra a ejecutar el cuerpo del ciclo,
líneas 3 y 4. La línea 3 imprime por consola el valor de i el cual es 0. La
instrucción 4 toma el valor de i (0) y le suma 5 para luego almacenar ese nuevo
resultado en i. Después la condición es nuevamente evaluada como i = 5 entonces
su resultado es verdadero y nuevamente se ejecutan las instrucciones de las líneas
3 y 4. Este proceso de evaluar la condición y ejecutar el cuerpo del ciclo while
continúa hasta cuando i <= 20.

Veamos las siguientes observaciones:

2.4.1 Cuando la variable i tenga el valor de 25 la condición se evaluará como

falsa y termina el ciclo.
2.4.2 Si se omite la instrucción i = i + 5; tendrá un ciclo (loop) infinito, ya que la
comparación siempre seria “0 <=20”, esta sería verdadera y el ciclo continuaría
infinitamente.
2.4.3 Se debe inicializar la variable de control i antes de ejecutar el ciclo. Si la
instrucción: i = 0; //línea 1 se omite, puede generar una de dos situaciones: el
compilador genera un error o el ciclo puede que no se ejecute.
 26
Estructura de Repeticion For

En la Figura 8 que aparece a continuación se muestra el diagrama de flujo para la

estructura FOR.

Figura 8. Diagrama de flujo ciclo FOR

Fuente: Tomado de Malik (2010, p.254)

La sintaxis del ciclo for es la siguiente:

for (expresión inicial; condición; actualizar expresión) { statement;

}

El ciclo for se ejecuta de la siguiente manera:

1. La expresión inicial (initial expression) se ejecuta. Usualmente esta

expresión es una variable que tiene que ser inicializada con un valor.
2. Se evalúa la condición (logical expression). Si el valor es verdadero se
ejecuta el cuerpo del ciclo for.
3. Se actualiza la variable definida en el paso 1.
4. Se repite el paso 2 hasta que la condición sea falsa.
Fundamentalmente los ciclos for se usan para implementar un ciclo controlado por un
contador.
2.7.5.1 Ejemplo del ciclo for

Imprimir los primeros 10 números no negativos enteros.

for ( i = 0; i < 10; i++) { System.out.println ( i + “ “);

}

Recuerde que ++ es un operador unario que hace incrementos de 1 sobre la

misma variable. Este no necesita de otro operando, i++ es lo mismo que escribir i = i
+1

Veamos como el anterior ejemplo es ejecutado la primera vez:

1. La variable i se inicializa con el valor 0

2. La condición (expression logical) i < 10, es evaluada. Dado que 0 es < 10, su
resultado es verdadero entonces se ejecuta la instrucción
System.out.println( i + “ “).
3. La variable i es incrementada en 1, i++.
4. Se repite el paso 2 y 3 hasta que la condición “i<0” sea negativa (false).
Esto quiere que el ciclo es ejecutado 10 veces.

Estructura de repetición do_while

Algunas veces se necesita ejecutar el cuerpo del ciclo por lo menos una vez y
 27
luego ejecutar la condición del ciclo después de que el cuerpo fue ejecutado. El
ciclo do … while sirve para este propósito.

La sintaxis es la siguiente:

do
statement
while (logical expression)

El cuerpo del ciclo (statement) debe ir cerrado entre corchetes { }. En Java la

palabra do es reservada y condición (logical expression) es la que chequea la
condición del ciclo. A continuación en la Figura 9 se presenta el diagrama de flujo
del ciclo do … while.

Figura 9. Diagrama flujo estructura Do....While

Nota: Tomado de (Malik, 2010), pág. 264

El cuerpo del ciclo (statement) se ejecuta primero, entonces luego se evalúa la

condición (logical expression), si es verdadera el cuerpo se ejecuta nuevamente.
Siempre que la condición sea verdadera se ejecutará el cuerpo del ciclo. Para
evitar un ciclo infinito debe asegurarse que dentro del cuerpo del ciclo haya una
instrucción que haga que la condición del ciclo se vuelva falsa para asegurarse
una salida adecuada del ciclo.
Ejemplo de la estructura de repetición do … while:

i = 0;
do {
System.out.println ( i + “ “); i = i + 5;

}
while ( i <= 20)

La salida por pantalla de este programa es:

0 5 10 15 20

Después que imprime el 20, la instrucción i = i + 20 cambia el valor de i a 25 lo

cual convierte la condición en falsa y por lo tanto se para la ejecución del ciclo.

Observe que debe iniciar la variable de control i antes de entrar a ejecutar el

cuerpo del ciclo
 28

2.7 Ejemplo de compilación de un algoritmo implementado en Java

Software necesario para trabajar con Java

1. Para poder adelantar la codificación de los programas que se escriban se

requiere del paquete JDK (Java Development Kit). La versión que se recomienda
usar es Java Platform, Enterprise Edition
2. Descargar
3. Dado que este es un curso orientado a iniciarse en el desarrollo de
software se requiere usar una herramienta integrada de ambiente de desarrollo (IDE
en inglés). Es un entorno integrado de desarrollo que cobija funcionalidades como
Editor para escribir el programa fuente, compilador para compilar el programa fuente,
depurador para encontrar los errores en el programa objeto. Además, se le pueden
adicionar componentes de propósito específico de acuerdo a las necesidades de
trabajo. Por ejemplo: componentes para modelar gráficamente la aplicación, control
de versiones de los programas, y programación para dispositivos móviles. Para el
presente módulo se va a usar el IDE Eclipse en su versión Helios para EE
developers.
4. Pasos necesarios para escribir su primer programa en Java

Debe abrir Eclipse, seleccionar su área de trabajo (workbench) en el ejemplo UMB.

La primera vez que ingrese a la plataforma le aparece el siguiente pantallazo

Debe dar clic sobre la X de la esquina superior izquierda donde dice Welcome.
A continuación, le aparece el entorno para trabajar en Java.

Seleccione el siguiente camino Window/Open perspective/Java como puede

observar en la siguiente captura de pantalla:
 29

Ya está listo para comenzar a escribir su primer programa. Seleccione

File/New/Java Project como aparece en la siguiente gráfica.

Luego digite el nombre del proyecto, para este caso puede ser Saludo. En la
siguiente gráfica lo puede observar. Y por último seleccione el botón finish.

En el panel Package Explorer sobre el ícono saludo oprima botón derecho

seleccione la opción New/class como se puede ver en la siguiente gráfica.
 30

Le aparece una ventana como la siguiente

Ingrese en Name MiPrimerPrograma y marque la opción public static void main, por
último, oprima el botón Finish. La gráfica le presenta lo mencionado anteriormente.
 31

El resultado de lo que hasta el momento se ha escrito se ve así:

Como puede observar el editor de Eclipse le ayuda a incluir unas líneas de código
por Ud. con el fin de aumentar su productividad. Igualmente por defecto el editor
maneja diferentes colores para las distintas partes del programa que está codificando.

Es muy útil durante la codificación numerar las líneas de código para ello siga
la siguiente secuencia Window/Preferences/General/Editors/Text Editors y en esa
pantalla seleccione la opción show line numbers oprima el botón apply y luego el
botón Ok.
 32

Después en el editor escriba las siguientes líneas de código como se muestra a

continuación. Como puede observar Eclipse ya numera automáticamente cada línea
de código.

Mi Primer Programa en Java

Por último, se necesita compilar el programa. Para ello debe dar clic sobre la
opción Run. Eclipse le muestra la siguiente pantalla y Ud. debe hacer clic sobre el
botón OK.

El resultado de su primer programa le aparece en la ventana de la consola así

 33

Análisis de las líneas de código

public class MiPrimerPrograma

Comienza una nueva clase. Clase es un concepto fundamental en Java. En Java

todo programa consta de una o más clases. Recuerde que una clase es una
plantilla o un diseño/plano que contiene las especificaciones que se concretarán más
adelante.

La palabra reservada public indica que la clase la puede usar el “publico”.

Por ahora sólo considere la siguiente estructura como parte de la “carpintería”
necesaria para escribir un programa en Java.

public class Class Name {

...
}
En Java, cada programa fuente puede contener máximo una public class y el
nombre de ésta debe ser igual al nombre del programa fuente que contiene la
clase pública. Esto es, la clase MiPrimerPrograma debe estar contenida en el
archivo MiPrimerPrograma.java.

Gráficamente se presenta a continuación

Public static void

Al definir la línea del program, public static void main(String[ ] args) {

...
}

Lo que se hace es lo siguiente:

 Define un método llamado main. Un método contiene una serie de instrucciones

para llevar a cabo una tarea particular. Toda aplicación en Java debe tener un
método main.
 El parámetro String [ ] args es una parte requerida del método main. La
palabra reservada static indica que el método main no funciona como un objeto.
En Java el método main siempre debe ser estático (static) porque éste
comienza a correr sin haber creado objetos antes.
 Como se puede ver en la Figura 10 dentro del método main están las
instrucciones que se requieren para ejecutar este primer programa.
 La primera línea dentro del método main es un comentario: // Muestra un saludo
 en la ventana de la consola. Este comentario es solamente para beneficio del
 lector del programa, para explicar más en detalle de qué se trata lo que hace
la siguiente instrucción, además para darle más claridad al programa. Cualquier
texto precedido por // hasta el final de la línea es ignorado por el compilador.
 Las instrucciones o sentencias dentro del cuerpo del método main, las
sentencias que están dentro de los corchetes { }, son ejecutadas una a una. Cada
 34
sentencia es
 finalizada con punto y coma (;). El método de este programa contiene una
sola
 sentencia, como se ve en el siguiente punto.

System.out.println("Hola mundo");

Esta instrucción imprime una línea de texto, textualmente “Hola Mundo”. Sin
embargo, hay varias formas en que un programa puede enviar ese texto: a una
ventana, a un archivo, a una red de computadores o a otra parte del mundo. Se
necesita especificar que el destino es System output esto es la consola.

En Java la consola se representa por un objeto llamado out. Así como se

necesitó colocar el método main dentro de una clase, MiPrimerPrograma, los
diseñadores de las librerías de Java necesitaron colocar el objeto out dentro de una
clase. Lo colocaron dentro de la clase System, la cual contiene una cantidad de
objetos y clases con funcionalidades para tener acceso a los recursos de la
computadora. Para usar el objeto out en la clase System se debe referir a este como
System.out.

Para usar un objeto, como System.out, usted debe especificar lo que quiere que
haga. En el caso del ejemplo, imprimir una línea de texto. El método println lleva a
cabo esta tarea. No se necesita implementar éste método, los programadores que
implementaron las librerías de Java ya lo hicieron previamente, pero lo único que
se tiene que hacer es invocarlo.

En cualquier parte del programa que necesite llamar a un método en Java, se

necesitan especificar tres cosas:

1. El objeto que quiere usar (en este caso, System.out). localice el

objeto out en la clase System
2. El nombre del método que quiere usar (en este caso, println). Quiere decir
“aplique el método println a ese objeto”.
3. Un par de paréntesis, que contengan la información que el método necesita
(en este caso, “Hola Mundo”). El término técnico para referirse a estos elementos
se llama
parámetros del método. Tenga en cuenta que los puntos en
System.out.println
tienen diferente significado.

Hay que tener en cuenta que cuando se trata de imprimir una cadena de
caracteres, este debe ir entre comillas. De lo contrario el compilador interpretaría
esta cadena de caracteres como el nombre de una variable o una palabra
reservada del lenguaje de programación. En el caso de los valores numéricos
estos son reconocidos como tal, ellos solo van entre los paréntesis. A
continuación tres ejemplos ilustrando lo antes dicho:

Ejemplo 1. Imprimiendo cadena de caracteres. Se invoca el método println dos

veces, por esta razón se imprimen dos líneas.

System.out.println (“Hola”);
Hola
System.out.println (“Mundo); Mundo

Ejemplo 2. Imprimiendo valores numéricos. En este caso se usa el método println

para imprimir la suma de dos valores numéricos.

System.out.println (3 + 4);
 35
7

Ejemplo 3. Aquí se usa el método print. Como se puede apreciar este método no
deja una línea entre la ejecución de la primera línea y la segunda, por el contrario
enlaza los dos resultados produciendo una sola línea.

System.out.print (“00”);
System.out.print (3+4); 007

3. JavaScript

JavaScript es un lenguaje producido por Netscape para uso dentro de páginas

de HTML. Por esta razón, es necesario que el estudioso, para desarrollar
programas usando este lenguaje, tenga conocimiento de HTML/XHTML y CSS.
Los anteriores, conforman junto con JavaScript una trilogía tecnológica que todos
los desarrolladores de páginas web deben aprender. Con HTML se especifica el
contenido de las páginas, CSS está relacionado con la presentación, y JavaScript
hace todo lo relacionado con el comportamiento de la página.

Adicionalmente, JavaScript es ejecutado en la máquina del cliente lo que quiere

decir que el software que interpreta programas escritos en JavaScript debe estar en el
cliente y puede ser cualquier browser, por ejemplo, Internet Explorer, FireFox,
Opera, Safari, Chrome, Egde, etc. El browser interpreta las órdenes que están
siendo dadas en JavaScript; por esta razón, es un lenguaje fácil de accesar.

Otra cosa muy importante que hay que tener en cuenta es que JavaScript no es
Java, estos son dos lenguajes de programación diferentes. El primero es un lenguaje
que no necesita ser compilado, mientras que el segundo necesita generar un
programa objeto para su ejecución. También, para utilizar Java se necesita de una
plataforma robusta, lo que no pasa con JavaScript, cualquier persona en su
computador puede usar esta herramienta.

En el Ejemplo de la sección 4.2 de JavaScript se introduce el lenguaje de

Programación JavaScript recordemos que es un lenguaje de scripting, el cual es
interpretado, es basado en objetos, y opera en el lado del cliente. De la misma
manera se evidencia la definición de variables, como utilizar mensajes para
documentar un programa, y como enviar mensajes a la pantalla.

Particularmente se evidencian los tipos de datos, los cuales son dinámicos, cadena
de caracteres (string), numéricos, booleanos o lógicos, y arreglos.

Observe que: en Java los datos son dinámicos. JavaScript puede cambiar el tipo de
dato de numérico a alfabético en un mismo programa.

Seguidamente y con el propósito de resolver situaciones un poco más complejas se

hace necesario el estudio de operadores, condicionales, y ciclos en JavaScript. Por
lo anterior se definirán estos nuevos elementos y por último se ilustrará
mediante ejemplos para un mejor entendimiento.

3.1 Operadores

Los operadores en JavaScript son utilizados principalmente para ejecutar

operaciones aritméticas, comparaciones, tareas de asignación, etc. Por esta razón es
necesario saber que existen operadores para manejar cada tipo de operación.
 36
Operadores de relación o comparación

Permiten comparar un valor con otro. Por ejemplo, si son iguales, diferentes, el uno
es mayor que el otro, etc. Seguidamente, en la Tabla 8, están especificados los
operadores de comparación que usa JavaScript. Estos operadores son iguales a
los que usa Java.

Tabla 8. Operadores de Comparación para JavaScript

Fuente: tomado de Goodman (2010, p..413)

Es importante resaltar que para JavaScript una letra en mayúsculas es diferente a la

misma letra en minúsculas. JavaScript es case-sensitive. Al momento de hacer
comparaciones con datos alfanuméricos se debe tener cuidado si la comparación
que se está haciendo es realmente lo que se quiere. Recuerde F es diferente que f.

Observe que: en la Tabla 8 en la columna `results`` se puede apreciar que todos

los valores son booleanos. Eso quiere decir que se recibe una respuesta en la forma de
`true` o `false`. Por ejemplo, es el `blanco` igual al `negro`, la respuesta es igual a
`false`.

Ejemplos de operadores de comparación

Asumimos que una variable x es igual a 5

1. En la expresión que compara x==9 el resultado es “falso” ya que 5 y 9 son

diferentes.
2. En la expresión que compara x<9 el resultado que retorna esta evaluación es
“true” ya que se cumple que 5 es menor que 9.

Operadores Aritméticos y Unarios.

Esta clasificación es hecha cubriendo los operadores aritméticos y otros

operadores con lo que se hacen operaciones entre más de un operando.
Esencialmente son todos aquellos con los que podemos hacer operaciones
aritméticas, tales como sumar (+), restar (-), multiplicar (*), dividir (/), etc.
Adicionalmente operadores como incremento, decremento, y concatenación de
caracteres. (Ver Tabla 9 para un mejor entendimiento).

Hay que tener en cuenta que al realizar operaciones complejas donde se

involucran más de dos operandos es necesario entender la precedencia de éstos
con el fin de obtener los resultados esperados.
 37
Tabla 9. Operadores Aritméticos en JavaScript

Nota: tomado de Goodman (2010, p 416).

Conviene destacar que el signo (+) puede efectuar operaciones con números
enteros y flotantes; igualmente con cadena de caracteres (string). Este último se
comporta como la suma de conjuntos.

También es importante resaltar que los operandos de Incremento (++) y

Decremento (--) son usados junto con los operandos de asignación. Estos
operandos son llamados operadores unarios (unary operators) ya que para su
ejecución solo requiere un operando. Algunos ejemplos son mostrados a
continuación:

Ejemplos de operadores aritméticos y/o unarios:

var a = 10; // inicializa la variable a en 10 var z = 0; //

inicializa la variable z en 0 z = a; // hace z y a iguales
z = ++a; // a es 11 antes de la asignación. Entonces a = 11 y
z es 11 z = a++; // a es 11 antes de la asignación. Entonces z=11 y
b es 12 z = a++; // a es 11 antes de la asignación. Entonces z=12 y
b es 13

Operadores Lógicos o Booleanos

El uso de estos operadores es muy importante considerando que los lenguajes de

programación usan la lógica aritmética. No es suficiente usar los operadores de
comparación para por ejemplo comparar si un valor es más grande o más pequeño
que otro. También es muy importante evaluar varias expresiones al mismo tiempo lo
que hace indispensable el uso de los operadores lógicos.

Esencialmente existen 3 operadores: y (AND), o (OR), y no (NOT) tal como se

observa en la Tabla 10.

Tabla 10. Operadores Lógicos o Booleanos en JavaScript

Nota: tomado de Goodman (2010, p 421).

En las Tablas 4, 5 y 6 de este documento se pueden ver las tablas que contienen
las tablas de verdad para los anteriores tres operadores.
 38
Observe que: en la Tabla 7 se puede ver la Precedencia de los todos los
operadores antes vistos. Los operadores en JavaScript tienen el mismo
comportamiento que aquellos para Java.

Ejemplo de operadores lógicos:

Asumimos que x es 2 y y es 2

1. En la expresión x<10 && y>1 se obtiene un resultado verdadero (true) ya

que la primera expresión, x<10 se cumple que 2 es menor que 10. Adicionalmente
el segundo término, y>1 es verdadero (true) porque 2 es mayor que 1. Teniendo
en cuenta la tabla de valor del operador “AND” el resultado final es verdadero
“true” ya que las dos expresiones son verdaderas.

3.2 Estructuras de decisión

Partiendo de la premisa que estas estructuras ya fueron previamente analizadas,

solo se mostrara su definición en JavaScript.
IF

Se utiliza esta estructura cuando solo hay una serie de pasos a ejecutarse cuando
una condición se cumple o es verdadera (“true”). Veamos la sintaxis:
If (condición) {
Sentencia o conjunto de instrucciones para cuando la condición es verdadera
}

Recuerde que: una sentencia es una serie de instrucción/instrucciones con un punto

y coma (;) al final de cada instrucción.

Ejemplos de IF

EJEMPLO 1

Saludar con un “Buenos días si la hora es menor o igual a las 12 P.M.

var x="";
var time=new Date().getHours(); if (time<=12) {
x="Buenos días";
}
IF … EL SE

Además d e e j e c u t a r c i e r t a s o r d e n e s cuando la condición es verdadera, se

necesita seguir otra serie de instrucciones cuando la condición no se cumple.

Veamos en JavaScript:

If (condición) {
Sentencia 1 cuando la condición se cumple o es verdadera
} else {
Sentencia 2 cuando la condición no se cumple
}
3.2.1.1 Ejemplos para IF … ELSE

EJEMPLO 1

A partir de un año dado, determinar cuántos días tiene el mes de febrero.

 39

Var theYear;
Var theYear = 2010;
If (theYear % 4 == 0) { diasFeb = 28;
} else {
diasFeb = 29;
}

Conviene destacar que la variable theYear fue dividida por cuatro, si el año es
divisible por 4 (residuo = 0) entonces Febrero tiene 29 días, sino (else) Febrero tiene
28 días.

Recuerde que: en JavaScript no es necesario definir el tipo de variable. En el

anterior ejemplo se definió una variable diasFeb, a la cual posteriormente se le
asignó un valor numérico (2010).

EJEMPLO 2

Dependiendo de la edad determinar si una persona es menor o mayor de edad.

Var laEdad;
Var laEdad = 52;
If (laEdad <= 18) {
tipoPersona = “es menor de edad”;
} Else {
tipoPersona = “es mayor de edad”;
}

En este ejemplo se debe preguntar por la edad, si la edad es menor o igual a 18

quiere decir que la persona es menor de edad, de otra manera es mayor de edad.
Else if

Este caso se usa cuando se necesita clasificar elementos de acuerdo a diferentes

condiciones. Por ejemplo, la clasificación por edad, de acuerdo a un rango la
persona es clasificada dentro de un grupo de edad. Veamos:

Ejemplos de Else…if

Ejemplo 1

De acuerdo a una edad dada, clasificar la persona en un grupo de edad. Para este
ejemplo se asume como parámetro de entrada la edad de “52”.

var grupoEdad;
var laEdad = 52;
If (laEdad <= 18) { grupoEdad = “adolescente”;
} else if (laEdad <= 30) {
grupoEdad = “entre 18 y 30”;
} else if (laEdad <= 40) {
grupoEdad = “ entre 40 y 50”;
} else {
grupoEdad = “mayor que 50”;
}

Notar que ninguna de las condiciones se cumple por lo que el programa envía el
control al ultimo else, lo que permite la asignación “mayor que 50” a la variable
grupoEdad.
Switch

Este es usado cuando es necesario usar if anidados. Veamos su sintaxis:

 40
switch (expression) {
case label1: [statements]; break; case label1: [statements]; break; [default: staments];
}

Ejemplos de la sentencia Switch

Reemplacemos el anterior ejercicio de if anidados con un switch. Para este

ejemplo tomemos 18 años en lugar de 52.

var grupoEdad; var laEdad = 18; switch (true) {

case (laEdad <= 18): grupoEdad = “adolescente”; break;
case (laEdad <= 30): grupoEdad = “entre 18 y 30”; break; case (laEdad <= 40):
grupoEdad = “ entre 40 y 50”; break; default: grupoEdad = “mayor que 50”;
}

Notar que después de cada condición que se cumple hay un break; para nuestro
ejemplo, tomando como base la edad de 18 años, la primera condición es la que se
cumple y envía el control al final del programa; al terminar, la variable grupoEdad
contiene la palabra “adolescente”.
3.3 Estructuras de Repetición

Generalmente las estructuras de repetición son usadas cuando una instrucción o

bloque de instrucciones tienen que ser ejecutadas varias veces hasta que una
condición se cumpla. Por ejemplo, estas estructuras son bastante utilizadas para
leer datos en un vector o una matriz.

En esta categoría encontramos tres bucles los cuales veremos a continuación:

Ciclo para (for)

El ciclo for ejecuta una serie de instrucciones hasta que cierta condición se cumpla.
Básicamente el ciclo usa un contador que se inicializa al comenzar el ciclo y que en
cada pasada se incrementa en uno. El proceso es ejecutado hasta que se exceda el
valor máximo. Veamos la sintaxis:

For (var i = startValue; i <= maxValue; i++)

{
Statement[s] inside loop
}

Recuerde que: hay que dar un valor inicial y especificar el valor máximo. i++
quiere decir que i se incrementa en 1 cada vez comenzando por 1. En la primera
vuelta del ciclo i es 1, en la segunda vuelta del ciclo, i comienza en 2 y así
sucesivamente hasta exceder el valor máximo.
3.2.1.2 Ejemplo para el ciclo for:

En este ejemplo el ciclo for se ejecuta cinco veces imprimiendo el número cada
vez.

var i = 0;
for (i=0; i<=5; i++);
{
document.write(“el número es: “ +i); document.write(“<br/>”);
}
Esta es la salida después de ejecutarse el programa: El número es: 1
El número es: 2
El número es: 3 El número es: 4 El número es: 5
 41
Ciclo Mientras (While)

El bucle while es lo mismo que el bucle for, solo que el primero no maneja el
contador automáticamente. El contador tiene que ser manejado dentro de la
sentencia que ejecuta el ciclo, e igual que el for, el ciclo se ejecuta hasta que una
condición no sea válida. La ventaja que tiene el while sobre el for es que su
escritura es más simple.

var i=starValue;
while (i <= maxValue)
{
Statement[s] inside loop; (bloque de instrucciones)
}

Ejemplos para el ciclo WHILE:

EJEMPLO 1. Imprimir los números del 1 al 5

var i = 1; while (i<=5)
{
document.write(“el número es: “ + x = “<br>”); x++;
}
Conviene destacar que el incremento de x tiene que ser incluido como una
instrucción más, de otra manera x no cambiaría de valor.

EJEMPLO 2. Realizar la suma de todos los números pares entre 2 y 1000

var i = 2;

var laSuma = 0; while (i<=1000)

{
laSuma = suma + i; i = i + 2;
}
document.write(“la suma de los número primos menores a 1000 es:“ + laSuma
= “<br>”);

Ciclo haga mientras (DO-WHILE)

El ciclo do-while se diferencia del while porque el primero ejecuta una serie de
instrucciones antes que la condición se pueda validar. Por esta razón este ciclo se
ejecuta al menos una vez. Veamos su sintaxis:

do
{
statements
} while (condition)
3.3.3.1 Ejemplos del bucle DO-WHILE

EJEMPLO 1. Imprimir los números del 1 al 5

var i = 1; do
{
document.write(“el número es: “ + i = “<br>”); i++;
}
while (i<=5)
Note que este caso es exactamente igual al caso en el que se usa solo el while.
Pero qué pasa si la variable se inicializa con el número 6? Con el do-while el
programa se ejecuta una sola vez imprimiendo “el número es: 6” y después valida
la condición y termina porque 6 no es menor o igual a 5. Por el contrario, en el ciclo
while el programa no hace nada desde que la condición no es verdadera.
 42
Trabajando con Arreglos

Como ya se dijo anteriormente un arreglo es otro tipo de variable. Es una variable

que puede guardar muchos valores. JavaScript puede manejar arreglos de una
sola dimensión o arreglos multidimensionales. En esta sección serán tenidos en
cuenta solamente vectores unidimensionales.

var myArray = new Array ( );

Igualmente se puede conocer la longitud de un arreglo mediante la palabra

reservada length:

myArray.length;
3.4.1.1 Ejemplos de Vectores

EJEMPLO 1: Crear un arreglo que contenga 6 valores

Var miCDColeccion = new Array (5)

En este ejemplo el vector es llamado miCDColeccion y es capaz de almacenar 6

valores.

Recuerde que: los índices de los vectores son numerados desde el número 0.
Veamos lo siguiente:
miCDColeccion[5] = “Celin Dion Album”; coleccionLong = miCDColeccion.length;

En el anterior caso, a la posición 5 del vector miCDColeccion se le asignó un valor, lo

que hace que la variable coleccionLong tenga el valor 6 ya que la primera
posición del vector es cero (0).

Conviene destacar que la longitud de un arreglo no es necesaria definirla al crear la

variable desde que JavaScript ajusta este valor de acuerdo a los valores dados. Por
ejemplo, si solo 3 valores fueron dados al arreglo entonces la longitud del
arreglo es 3.

EJEMPLO 2. Asignar los valores al vector llamado miCDColeccion Para poblar el

vector miCDColeccion se hace lo siguiente:
miCDColeccion[0] = “Hector Lavoe”; miCDColeccion[1] = “Celia Cruz”;
miCDColeccion[2] = “Jennifer López”; miCDColeccion[3] = “Marc Anthony”;
miCDColeccion[4] = “Bon Jovi”; miCDColeccion[5] = “Celin Dion”;

Igualmente el vector puede ser poblado como sigue:

miCDColeccion[miCDColeccion.length] = “Hector Lavoe”;

miCDColeccion[miCDColeccion.length] = “Celia Cruz”;

miCDColeccion[miCDColeccion.length] = “Jennifer Lopez”;

miCDColeccion[miCDColeccion.length] = “Marc Anthony”;
miCDColeccion[miCDColeccion.length] = “Bon Jovi”;
miCDColeccion[miCDColeccion.length] = “Celin Dion”;

3.4 Captura de Errores

Cuando se escribe un programa es necesario saber la clase de error en que se

incurre para determinar que se tiene que hacer en vía de corregir el problema.
Detectar un error a veces es una tarea difícil desde que se pueden cometer
errores de sintaxis o de ejecución. Considerando que JavaScript es un lenguaje
interpretado es siempre buena idea contemplar en el código el manejo de errores.

JavaScript maneja dos eventos que le permiten capturar errores; el primero es

onerror y el segundo es try… catch. Veamos su funcionalidad:
 43

Onerror

Es importante saber que cualquier elemento en una página web tiene eventos que
pueden disparar funciones de JavaScript. No es la competencia del presente
modulo analizar las funciones ya que estas serán vistas en el Modulo d o s , pero
con el fin de mostrar el uso de este comando se mostrará la creación de una de
ellas. A continuación, se muestra un script empleando el evento onerror:

<script>
onerror = errorHandler document.writ(“Bienvenido”)
Function errorHandler (message, url, line)
{
out = “disculpe, pero un error fue encontrado.\n\n”; out += “error: “ + message + “\n”;
out += “URL:” + url + “\n”;
out += “line:” + line + “\n\n”;
out += “presione ok para continuar.\n\n”; alert(out)
return true;
}
</script>

La primera línea del script muestra que el evento onerror va a usar la función
errorHandler la cual se definió posteriormente. La función toma tres parámetros de
entrada (message, url, y line number) y posteriormente lo muestra en una
ventana pop-up describiendo el tipo de error que para este caso fue un problema de
sintaxis en la línea denotada en amarillo.

Try … Catch

Este tipo de evento no permite capturar errores de sintaxis, pero son más flexibles
que el evento onerror desde que se pueden manejar excepciones o errores que se
comenten durante la ejecución de un programa.

Con el evento try…catch, es posible capturar errores y enviar un mensaje al

usuario de una manera más amigable. Capturando la excepción y controlando el
mensaje hace mejor la ejecución de un programa, de otra manera el usuario se
vería enfrentando a errores que no entendería.

<html>
<head><title>Try/Catch</title>
<script type="text/javascript">
Try :// este bloque contiene qué va a hacer analizado como possible error
{
alert("Current balance is $:" + get_balance());

catch(err) :// este bloque captura el error y envía un mensaje

{
alert("Ocurrió un error! \n"+
err.name + ": "+ err.message); ://nombre y mensaje del tipo de error
}
</script>
</head>
</html>

4. Ejemplos

En el presente capitulo se dieron todos los elementos básicos necesarios para el

desarrollo de programas de mediana complejidad. Es importante recordar sus
elementos y tener clara su definición. La sintaxis de estos elementos fue vista
tanto en Java como en JavaScript. Hay que recordar que Java es un lenguaje de
alto nivel que para su ejecución necesita ser compilado. Por otra parte JavaScript es
 44
un lenguaje interpretado.
4.1 Ejemplos de Java

EJEMPLO 1. Busca un elemento en un arreglo.

// BreakDemo.java
// busca un elemento en un arreglo public class BreakDemo {
public static void main(String[] args) {
int[] arregloDeInts = { 32, 87, 3, 589, 12, 1076, 2000, 8, 622, 127 };

int buscado = 12;

int i = 0;
boolean hallado = false;

for ( ; i < arregloDeInts.length; i++) { if (arregloDeInts[i] == buscado) {

hallado = true;
break;
}
}
if (hallado) {
System.out.println("Hallado " + buscado + " en lugar " + i + ".");
} else {
System.out.println("Valor " + buscado + "no fue encontrado.");
}
}
}

EJEMPLO 2. Búsqueda en un arreglo de dos dimensiones

// BreakRotuloDemo.java
// búsqueda en arreglo de 2 dimensiones

public class BreakRotuloDemo { public static void main(String[] args) {

int[][] arregloDeInts = { { 32, 87, 3, 589 },

{ 12, 1076, 2000, 8 },
{ 622, 127, 77, 955 }
};
int buscado = 12;

int i = 0; int j = 0;
boolean hallado = false;

buscar:
for ( ; i < arregloDeInts.length; i++) {
for (j = 0; j < arregloDeInts[i].length; j++) { if (arregloDeInts[i][j] == buscado) { hallado =
true;
break buscar;
}
}
}

if (hallado) {
System.out.println("Se halló " + buscado + " en " + i + ", " + j);
} else {
System.out.println("No se halló " + buscado);
}
}
}

Los anteriores ejemplos fueron proporcionados para que el estudiante corrobore en

general un programa desarrollado en Java y entienda mejor su estructura.
Igualmente se recomienda hacer modificaciones y practicar su ejecución en la
 45
plataforma IDE.

4.2 Ejemplos JavaScript

Todo lo que se necesita para empezar a escribir programas en este lenguaje se

especifican a continuación:

1. Se necesita un editor donde pueda escribir las instrucciones, este puede ser
cualquier procesador de texto, por ejemplo, en Windows, este puede ser WordPad y
en Mac, este puede ser MacText.
2. Escoger un browser o navegador de internet, este puede ser el que
usualmente se usa para acceder al internet. Se recomienda usar versiones de
Internet Explorer mayores a 5.0, ya que los ejercicios proveídos en este documento
no corren en browser con versiones más viejas.
3. Todo lo que se escribe en el editor se debe grabar como: anyName.html,
siendo este un archivo tipo texto. Posteriormente se debe ir al browser y abrir el
archivo. Se recomienda que el browser este “offline”; así, el enfoque es únicamente
con la prueba de los ejercicios aquí planteados.

Considerando que JavaScript es un lenguaje que funciona en la parte del cliente y

que necesita ser incluido dentro de un programa HTML, se mostrarán las
instrucciones básicas de éste con el fin de que los ejemplos proveídos
posteriormente en JavaScript puedan ser entendidos por el estudioso.

A continuación, se mostrarán las etiquetas del HTML básicas y necesarias para

entender los problemas aquí propuestos.

4.3 Ejemplo de un programa en HTML

En la primera línea del ejemplo mostrado en la Figura 12, mediante la palabra

DOCTYPE se especifica el standard contra el cual se debe validar el documento,
en este caso usamos HTML 4.01.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

Todo bloque de instrucciones en un programa en HTML esta contenido dentro de

dos etiquetas, una que indica el comienzo y otra que indica el final, de la siguiente
 46
manera:

1. <html></html> : Crea el documento

La primera etiqueta quiere decir que se va a crear un documento en HTML, con

la segunda etiqueta se termina el documento. Dentro de este par de etiquetas
vienen todas las demás, veamos:

1. <head></head> : Cabecera del documento

En esta parte del documento se define, por ejemplo, el título, variables, funciones,
etc.
En el ejemplo (Figura 13) dentro de la cabecera se encuentran otros pares de
etiquetas que son:

a. <title></title>: Dentro de esta etiqueta se define el título del programa

b. <script></script>: Aquí va un bloque de JavaScript. En nuestro ejemplo se
definió una variable llamada i.

Observe que, en la Figura 13 se puede apreciar que las etiquetas de la

cabecera
<head></head> van al mismo nivel del cuerpo del documento <body></body>,
eso quiere decir, que antes de definir el cuerpo del documento se debe cerrar la
cabecera.

2. <body></body> : Cuerpo del documento

En este par de etiquetas va usualmente lo que se va a mostrar en la pantalla o

página de un sitio internet. Aquí también pueden ir bloques de JavaScript, para
nuestro caso, se está imprimiendo un valor mediante un método llamado
document.writeln.

Se recomienda validar la página con el fin de corregir posibles problemas de sintaxis

o uso de etiquetas.

En la Figura 13 se puede ver el resultado obtenido al someter un HTML al validador

de W3C. Con el fin de saber cuáles son los tipos de errores se debe abrir la
pestaña “ validation output”, donde se proporciona que causó el error y dan una
sugerencia de la posible solución.

Uso de etiquetas (Tags) <script>, </script>

Asumiendo que se tiene un conocimiento básico de HTML se va a introducir un

bloque de JavaScript dentro de un programa escrito en HTML. Hay que tener en
cuenta que toda instrucción escrita en JavaScript va dentro de las etiquetas
<script></script>.

Un bloque de JavaScript puede ir en cualquier parte del html, depende para qué
se quiere usar. Por ejemplo, en la Figura 13, las Instrucciones de JavaScript van
dentro del cuerpo del html. Podemos afirmar que JavaScript puede ser usado para:

 Definir o inicializar una variable

 Asignar un valor a una propiedad o a una variable

 Cambiar el valor de una propiedad o variable
 Definir o invocar un método
 Definir o invocar una función
 Tomar una decisión
 47
En el ejemplo que se muestra a continuación se puede ver el uso de una función
que escribe un mensaje en pantalla.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD

HTML
4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html lang="EN">
<head>
<title>Mi Primer Programa</title>
</head>
<body> Mi primer Programa
<script type="text/javascript">
document.write("Mi primer Programa");
</script>
</body>
</html>
 48
La línea <script type=”text/javascript”>, le está indicando al browser que el texto
escrito dentro de las etiquetas <script> y </script> debe ser tratado como de
javaScript.

En el anterior caso tenemos que el programa está haciendo un llamado a la

función document.write para escribir en pantalla el mensaje “Mi primer programa”.
Solo invocando la función podemos escribir cualquier cosa en un browser. Lo único
que se tiene que saber es como utilizarla.

Adicionalmente, se agrego un mensaje con doble slash (//). Estos mensajes son
solo usados para hacer aclaraciones al programa, pero no son vistos al momento
de su ejecución en el browser y solo se puede escribir una línea. Otro modo de
escribir mensajes dentro de un programa es escribir el mensaje en más de una línea
como se especifica posteriormente:

/* esto es
un comentario escrito en más de una línea*/

Atributos de la etiqueta <script>

1. Language (lenguaje): Indica el lenguaje. Usualmente este atributo se asigna

con “JavaScript”.

<script language=”JavaScript”>
</script>

1. Type (tipo): Identifica el tipo del contenido y el lenguaje de script.

<script language=”JavaScript” type=”text/javascript”>

</script>

2. Src (fuente): Este atributo especifica el nombre del archivo de javaScript

cuando el programa fue escrito en un archivo externo. Por ejemplo la parte de
Javascript fue escrita y grabada en un archivo nombreArchivo.js
<script language=”JavaScript” type=”text/javascript” src=nombreArchivo.js>
</script>

Todo programa de JavaScript puede ser escrito en un editor de texto y salvado

bajo cualquier nombre con una extensión .html. Recuerde que el programa de
JavaScript esta embebido dentro de un HTML. Para ejecutar los programas hechos
durante este módulo se puede abrir el archivo en un explorador internet.
 49
Glosario

Algoritmo: Conjunto de operaciones computacionales no ambiguas que se

ejecutan organizada y efectivamente produciendo un resultado en cierta cantidad de
tiempo.

Expresión: Es una combinación de constantes, variables, y/o funciones que son

analizadas por un lenguaje de programación. Ellas pueden ser aritméticas o lógicas.
Ejemplo, una formula algebraica.
Operador de asignación: En la mayoría de lenguajes este operador es el signo igual
(=) y permite asignar valores a una variable o a una constante.
Operadores lógicos: Son utilizados para hacer comparaciones lógicas. Permite
por ejemplo analizar más de una expresión. Por ejemplo (A AND B) > (D OR E),
donde AND y OR son los operadores lógicos.

Expresión lógica: Es aquella expresión que usa los conectores lógicos como Y
(AND), OR(O), para hacer comparaciones.

Orden de precedencia: Los lenguajes de programación manejan el nivel de

precedencia para los operadores aritméticos, lógicos y de comparación. Eso quiere
decir que la operación que se ejecuta primero es aquella cuyo operador tiene el
nivel de precedencia más alto.
Sentencias: Son aquellos comandos o instrucciones que son escritos dentro de un
programa y que ejecutan tareas específicas. Tal es el caso, de una asignación o la
impresión de un mensaje en pantalla.
Condición: Una condición no es más que una comparación que es utilizada para
cambiar el flujo de un programa, de otra manera los programas ejecutarían solo
instrucciones secuenciales.

Función: También conocida como: subprograma, procedimiento o rutina. Una

función es creada dentro de un algoritmo como una rutina independiente que
ejecuta una tarea específica. Igualmente, una función puede ser llamada por otra
función.
Parámetro: Es una variable de entrada que es dada a un programa o subrutina
(función) que sirve para alterar su comportamiento durante la ejecución. Por ejemplo,
a un programa/subrutina que convierte los grados Celsius en Fahrenheit, los grados-
Celsius constituyen un parámetro de entrada.

Plataforma: Es un ambiente computacional donde la plataforma tiene que ser

compatible con la máquina y las aplicaciones. Se habla de sistemas operativos,
lenguajes de programación, e interfaz de usuario. Un ejemplo de plataforma para la
ejecución de programas Java, es ECLIPSE.
Pivote: Es un valor central alrededor del cual se hacen comparaciones o cálculos.
En este documento se refiere a un valor que se deja fijo en un arreglo y se
compara con otros valores dentro del mismo arreglo.
Bibliografía

Friesen, J. (2011). Beginning Java 7. New York: Apress.

Gilley,W.S., Robin, A. & Tunar, E. (s.f.). Animations to assist learning some key
computer science topics. Algorithms.
http://courses.cs.vt.edu/~csonline/Algorithms/Lessons/SpecifyingAlgorithms/ index.html

Goodman, D., Morrison M., Novitski, P. & Gustaff, T. (2010). JavaScript Bible.

Joyanes Aguilar, L. & Zahonero Martinez, I. (2004). Algoritmo y Estructura de

Datos. Una Perspectiva en C. Cap.6. EE.UU.: McGraw-Hill. Recuperado de
http://novella.mhhe.com/sites/dl/free/844814077x/619434/A06.pdf

Malik, D. (2010). Java Programming: from problem analysis to program design,

(4a. Ed.). Boston, MA: Cengage Learning.

Nixon, R. (2012). PHP, MySQL, JavaScript, & CSS (2ª. Ed.), pp.318-320.
Programming Fundamentals (7a. Ed.), cap.8-12. Indianapolis, EE.UU.: Wiley
Publishing Inc.

Quigley, Ellie (2010). JavaScript by Examples, (2ª Ed). EE.UU: Pearson

Education, Inc.
Sebastopol, California, EE.UU.: O’Reilly Media Inc.

Téllez Rivera, M. (s.f.). Aplicaciones Informáticas. Recuperado de

http://boalm.com.mx/index_archivos/ARCHIVOS/A_INF_2_1.pdf.