1

Algoritmia y programación

Hugo Alfonso Ortiz Barrero

Fecha de actualización: 15 de julio de 2024 (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 vistosen 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
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 buen
2448 y 5746. estado, una rueda de reemplazo y una llave
Inicio inglesa.
1. Colocar los números el primero
unidades, decenas, centenas encima delInicio
segundo, de tal manera que las, etc., de
1. Aflojar los tornillos de la rueda
los números queden alineadas. Trazar una
pinchada con la llave inglesa.
línea debajo del segundo número.
2. Empezar por la columna más a la2. Ubicar el gato mecánico en su
sitio.
derecha.
3. Levantar el gato hasta que la rueda
3. Sumar los dígitos de dicha
pinchada pueda girar libremente.
columna.
4. Quitar los tornillos y la rueda pinchada.
4. Si la suma es mayor a 9 anotar un
5. Poner rueda de repuesto y los tornillos.
1 encima de la siguiente columna a la
6. Bajar el gato hasta que se pueda
izquierda y anotar debajo de la línea las
liberar.
unidades de la suma. Si no es mayor anotar
7. Sacar el gato de su sitio.
la suma debajo de la línea.
8. Apretar los tornillos con la llave inglesa.
5. Si hay más columnas a la
izquierda, pasar a la siguiente columna aFin
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 ennuestras
vidas que no resolvemos problemas de la mejor manera, nos complicamosun 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, yunas son mejores que
otras.

Es bueno tener en cuenta que para construir un algoritmo primero que todo hayque
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 debeser 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) Cadenade 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, unnombre 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 dedatos.

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

Preciso
Secuencial Debe ser Algoritmo ejecuta Sentencias
Finito

asigna
son

toma Son de
Genera

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
retiro;
la circunsferencia
El radio de la
circunferenccia
VEectores
Mnatrices
Cat dena de
caeracteres
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 entreel
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 elobjeto
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 posteriormentecomo

á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 puede 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 porsí 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 quedeben
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, osea

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 icon 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 yproducen
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 2se 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úmerode 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ónno 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 deflujo.

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 ladosi 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 entoncessu 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 flujodel 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 unainstrucció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 (IDEen 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, controlde 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 sigala
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 quehaga.
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 quese 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íaesta 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);

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

Por otro lado, existen muchos más ambientes integrados de desarrollo (IDEs) para
programar en lenguaje Java, algunos son NetBeans, Apache Netbeans, BlueJ, Visual
Studio Code ente otros.

3. JavaScript

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

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 todoslos 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 JavaScripthace 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. Porlo
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ónque
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. Adicionalmenteel
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 de e jecu tar c ie r ta s ordenes 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 elcontrol
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 cadavez.

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 seincurre

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 dos, pero con el fin
de mostrar el uso de este comando se mostrará la creación de una deellas. 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 elmensaje hace
mejor la ejecución de un programa, de otra manera el usuario severí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 queusualmente
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 elarchivo.
Se recomienda que el browser este “offline”; así, el enfoque es únicamentecon 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 unasugerencia 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
HTML

<html lang="EN">
<head>

</head>
<body> Mi primer Programa

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

Se recomienda al construir paginas web que tengan interacción con algoritmos escritos
en el lenguaje Java Script se construyan de esta manera.
 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.