Funciones y Procedimientos con Parámetros

1) ¿Qué es el “tipo de dato”?
2) ¿Cuáles tipos de datos existen y que valores pueden contener?

3) Defina el concepto de variable. ¿En qué lugar de nuestras computadoras son
guardadas las mismas?
4) ¿Qué diferencia a una constante de una variable?
5) ¿Qué diferencia hay entre una variable que tenga como valor ‘3’ de una que
tenga como valor “3” y otra cuyo valor sea 3?
1) Es la característica que tiene un valor que determina las operaciones que se

pueden realizar y cómo es almacenado en la memoria, estos valores pueden ser
constantes o variables.
Es la forma de imponer restricciones en los datos, como qué valores pueden
tomar y qué operaciones se pueden realizar. Todos los valores que aparecen en
un programa tienen un tipo.
2) Los tipos de datos pueden se estándar o definidos por el Usuario.
Entero: puede contener un numero entero positivo o negativo incluyendo el

cero.
Real: Números reales. La cantidad de decimales que tenga un número dependerá

de la cantidad de memoria disponible para ese número.
Carácter: Un solo símbolo (letra, digito, signo, etc.)
Cadena: Un conjunto de caracteres (palabra, frase, etc.)
Lógico: verdadero o falso
3) Las variables son datos que van cambiando en la ejecución de programas. Se

guardan en la memoria.
4) Variable: Su valor varia o se modifica durante la ejecución del algoritmo.
Constante: Su valor NO varía durante la ejecución del algoritmo.
5) El Primero es tipo Carácter, el segundo tipo Cadena y el tercero tipo Entero
“3”: Dato de tipo Cadena
‘3’: Dato de tipo Carácter
3: Dato de tipo Entero

Función ValorAbsoluto (NUM:ENTERO):ENTERO
VAR ABSOLUTO : ENTERO
Si (NUM < 0) entonces
ABSOLUTO <- NUM*(-1)
Sino
ABSOLUTO <- NUM
FinSi
Devolver (ABSOLUTO)
FinFunción
-----------------------------------------------------------
VARIABLES
N, ABS : ENTERO
INICIO
Mostrar (“Ingrese un número o 0 para finalizar”)
Ingresar (N)
Mientras (N <> 0) Hacer
ABS <- ValorAbsoluto(N)
Mostrar (“El valor absoluto de ”,N,” es:”, ABS
Mostrar (“Ingrese un número o 0 para finalizar”)
Ingresar (N)
FinMientras
FIN
Funcion que devuelva el valor absoluto de un numero entero.
Procedimientos con parámetros de entrada y salida

PROCEDIMIENTO Division(NUM1, NUM2: ENTERO; C, R: ENTERO)
C <- NUM1 DIV NUM2
R <- NUM1 RESTO NUM2
FINPROCEDIMIENTO
En la siguiente sección nos dedicaremos con más detalle a los parámetros y te

explicaremos cómo especificar aquellos que son de entrada y aquellos que son
de salida.
SEUDOCÓDIGO
VAR N1, N2, C, R: ENTERO
INICIO
Mostrar (“Ingrese el Dividendo:”)
Ingresar (N1)
Mostrar (“Ingrese el Divisor:”)
Ingresar (N2)
Division (N1, N2, C, R)
Mostrar (“La división entera es:”, C)
Mostrar (“El resto de la división entera es:”, R)
FIN
Procedimientos solo con parámetros de entrada

PROCEDIMIENTO InformarResultado(TOTAL: REAL)
Mostrar (“Informe de Resultados”)
Mostrar (“El total es: ”,TOTAL)
FINPROCEDIMIENTO
Procedimientos solo con parámetros de salida

PROCEDIMIENTO ObtenerEdad(EDAD: ENTERO)
Mostrar (“Ingrese su edad”)
Ingresar (EDAD)
FINPROCEDIMIENTO
Procedimientos sin parámetros

PROCEDIMIENTO Saludo()
Mostrar (“Bienvenido al sistema”)
Mostrar (“Este programa fue desarrollado por Juan Pérez”)
FINPROCEDIMIENTO
Veamos cómo se define un procedimiento de manera general.

PROCEDIMIENTO Nombre(lista de parámetros)
Acción1
Acción2
....
AcciónN
FINPROCEDIMIENTO
Del mismo modo que las Funciones, para definir un Procedimiento tenemos la
palabra reservada PROCEDIMIENTO, la cual indicará que todo lo que se
encuentre hasta el FINPROCEDIMIENTO corresponderá a la rutina.
Los PROCEDIMIENTOS no devuelven un resultado asociado a su nombre, es
por eso que no tienen un Tipo de Dato asociado. Si el procedimiento tuviese que
devolver uno o más resultados, los devolverá a través de los parámetros de salida.
Un Procedimiento es una rutina que puede devolver uno, muchos o incluso
ningún resultado, dependiendo de sus parámetros de entrada y de salida.
Procedimiento que solicite al usuario un número entero por teclado y

valide que se trate de un número mayor o igual a cero. Luego, elaborá un
programa que lea números por teclado (hasta ingresar un 0) y emita la
suma de todos los números leídos.
SEUDOCÓDIGO
Procedimiento ObtenerEnteroPositivo (NUM:ENTERO)
Repetir
Mostrar (“Ingrese un número entero mayor o igual a cero”)
Ingresar (NUM)
Hasta que NUM >= 0
FinProcedimiento
--------------------------------------------------------------
VARIABLES
N, SUMA : ENTERO
INICIO
SUMA <- 0
ObtenerEnteroPositivo(N)
Mientras (N <> 0) Hacer
SUMA <- SUMA + N
ObtenerEnteroPositivo(N)
FinMientras
Mostrar (“La suma de los números ingresados es:”, SUMA)
FIN
La comunicación entre las rutinas y el algoritmo que las invoca se realiza por
medio de Parámetros.
Mediante los Parámetros podremos lograr la Abstracción y el Ocultamiento de la

información, características fundamentales en el momento de dividir un algoritmo en
módulos.
A los parámetros que se encuentran en la definición de la rutina se los conoce

como Parámetros formales o efectivos. A los parámetros que se encuentran en la
invocación de la rutina se los llama Parámetros actuales o reales.
Cuando se invoca a una rutina que presenta parámetros, los mismos deben
sustituirse por algunos de los métodos de sustitución, los cuales pueden ser
sustitución por valor o sustitución por referencia.
Parámetros por Valor

Cuando un parámetro se sustituye por Valor, se crea en el área de memoria
asignado a la rutina, un nuevo espacio para almacenar el valor del parámetro. Es
como si se realizara una copia del parámetro actual (el parámetro de la llamada)
pero ahora será identificada con el nombre del parámetro formal (el parámetro
del encabezado).
Es importante aclarar que los nombres de los parámetros no tienen por qué
coincidir. Ya habrás notado esto en los ejemplos anteriores. Lo que sí tiene que
coincidir es el tipo de datos de los parámetros, de lo contrario no se podrá
realizar la asignación del valor.
 Jessica Puiszo
Técnicas de Programación
1. Página Principal
2. Mis cursos
3. Técnicas de Programación_1
4. UNIDAD 6
5. Funciones y Procedimientos
Funciones y Procedimientos
1. Parámetros por Valor
Cuando un parámetro se sustituye por Valor, se crea en el área de memoria asignado a
la rutina, un nuevo espacio para almacenar el valor del parámetro. Es como si se realizara
una copia del parámetro actual (el parámetro de la llamada) pero ahora será identificada
con el nombre del parámetro formal (el parámetro del encabezado).
Es importante aclarar que los nombres de los parámetros no tienen por qué coincidir. Ya
habrás notado esto en los ejemplos anteriores. Lo que sí tiene que coincidir es el tipo de
datos de los parámetros, de lo contrario no se podrá realizar la asignación del valor.
La sustitución de parámetros se realiza de manera posicional, y debe haber en la llamada
a la rutina la misma cantidad de parámetros que los definidos en el encabezado.
Identificamos a los parámetros que se sustituyen por valor anteponiendo la palabra

reservada VALOR. De esta manera, el encabezado de una función podría ser de la
siguiente manera:
FUNCIÓN Promedio (VALOR NUM1:ENTERO, VALOR NUM2:ENTERO):REAL
También, podemos agrupar la definición en una forma equivalente:
FUNCIÓN Promedio (VALOR NUM1, NUM2:ENTERO):REAL
Ambas definiciones nos indican que los dos parámetros de tipo de dato ENTERO, NUM1
y NUM2 se sustituyen por valor.
Seguramente notarás que el valor del parámetro formal se modifica, pero como
ocupa un área de memoria distinta al parámetro actual, este no se ve
alterado. Por lo tanto, a un parámetro que se sustituya por valor nunca se le
cambiará su contenido desde la rutina.
Los parámetros de Entrada se deben sustituir por Valor.

Parámetros por Referencia
Cuando un parámetro se sustituye por referencia, se crea en el área de memoria
asignado a la rutina, un enlace hacia el parámetro actual. De este modo, el nombre del
parámetro formal (el del encabezado de la rutina) estará asociado a la misma área de
memoria del parámetro actual.
Tendremos dos identificadores apuntando al mismo espacio de memoria.
Identificamos a los parámetros que se sustituyen por referencia anteponiendo la palabra

reservada REF. De esta manera, el encabezado de un procedimiento podría ser de la
siguiente manera:
PROCEDIMIENTO ObtenerEdad(REF EDAD: ENTERO)
Esta definición nos indica que el parámetro de tipo de dato ENTERO, EDAD se
sustituye por referencia.
Seguramente notarás que el valor del parámetro formal se modifica y, además,

como ocupa la misma área de memoria que el parámetro actual, este también se
verá actualizado. Por lo tanto, a un parámetro que se sustituya por referencia se
le podrá cambiar su contenido desde la rutina.
Los parámetros de Salida se deben sustituir por Referencia.
Ejercicio parámetros el método de sustitución
Función ValorAbsoluto (valor NUM:ENTERO):ENTERO VAR ABSOLUTO : ENTERO

Si (NUM < 0) entonces
ABSOLUTO <- NUM*(-1)
Sino
ABSOLUTO <- NUM
FinSi
Devolver (ABSOLUTO)
FinFunción
------------------------------------------------------------Procedimiento
ObtenerEnteroPositivo (referencia NUM:ENTERO)
Repetir
Mostrar (“Ingrese un número entero mayor o igual a cero”)
Ingresar (NUM)
Hasta que NUM >= 0
FinProcedimiento
Variable es un espacio en memoria asociado a un nombre lógico.
Es por eso que las variables y todos los componentes de nuestro algoritmo utilizarán ese
espacio de memoria. Estas secciones son conocidas como ámbitos de ejecución.
Las variables, constantes, rutinas y todo el algoritmo serán almacenados en el ámbito
del programa. Pero del mismo modo que te explicamos el concepto de dividir por
módulos un algoritmo, el área de memoria se encuentra, también, dividida generando
los distintos ámbitos de memoria de cada rutina.
Por lo tanto, tendremos un ámbito de memoria global para nuestro algoritmo principal,
y cada rutina tendrá definido un ámbito de memoria local, el cual será de acceso
exclusivo dentro de esa rutina.
La división de estos ámbitos nos permite clasificar las variables en globales y locales.
Variables Globales
Las Variables Globales son aquellas que se definen en el programa principal. Si bien
estas variables están accesibles desde el algoritmo principal y desde todas las rutinas, es
un error grave acceder directamente a ellas desde una rutina.
Para acceder a una variable global desde una rutina se debe pasar a la variable como un
parámetro. De esta manera logramos mantener la abstracción, ya que desde la rutina no
se tendrá acceso directamente a un componente que no se encuentra definido en ella.
A las Variables Globales se deben acceder solamente desde el programa principal,

de lo contrario no estaremos realizando una abstracción de los módulos.
Variables Locales
Las variables locales son aquellas que se definen dentro de una rutina. A estas variables
se pueden acceder solamente dentro de la misma rutina, ya que se encuentran
almacenadas en el ámbito de la propia rutina. Cuando una rutina se invoca, se crea en
memoria el ámbito de ese módulo, que es donde se almacenan los parámetros y las
variables locales.
Una vez que finaliza la rutina, se elimina su ámbito de memoria, borrándose todos los
parámetros y variables locales.
A las Variables Locales se deben acceder solamente desde la rutina en que se

definieron, de lo contrario no estaremos realizando un ocultamiento de la
información apropiado.
Problema:
Desarrollar una rutina que muestre todos los divisores positivos de un entero y, otra
rutina, que devuelva la cantidad total de los mismos. Luego escribir un programa que
ingrese un número positivo y muestre sus divisores y la cantidad de divisores que posee.
Procedimiento MostrarDivisores (valor N:ENTERO)
VAR I : ENTERO
Para I <- 1 hasta N Hacer
Si (N RESTO I = 0) entonces
Mostrar (I)
FinSi
FinPara
FinProcedimiento
Función CantidadDivisores (valor NUM:ENTERO):ENTERO

VAR I,CANT : ENTERO
CANT <- 0
Para I <- 1 hasta N Hacer
Si (N RESTO I = 0) entonces
CANT <- CANT + 1
FinSi
FinPara
Devolver (CANT)
FinFunción
VARIABLES
NUM : ENTERO
INICIO
Mostrar (“Ingrese un número entero”)
Ingresar (NUM)
MostrarDivisores (NUM)
Mostrar (NUM, “tiene”, CantidadDivisores(NUM), “divisores”)
FIN
Síntesis de la unidad
En esta unidad te presentamos una estrategia para poder construir PROGRAMAS más
complejos. Utilizamos la DIVISIÓN POR MÓDULOS para dividir el PROBLEMA en
subproblemas y, de esa manera, simplificar el desarrollo.
También te comentamos cuáles son los beneficios de desarrollar módulos o

RUTINAS. Luego, vimos los conceptos de ABSTRACCIÓN y OCULTAMIENTO DE LA
INFORMACIÓN, que surgen como consecuencia de dividir un programa en módulos.
Te explicamos que los módulos en nuestros programas serán FUNCIONES o

PROCEDIMIENTOS. La diferencia entre ambos tipos de rutinas es que una Función
devuelve un único RESULTADO asociado a su nombre, mientras que un Procedimiento
puede devolver uno, muchos o incluso ningún resultado.
En esta sexta unidad te presentamos ejemplos de Funciones y de Procedimientos

con PARÁMETROS DE ENTRADA, PARÁMETROS DE SALIDA y sin parámetros.
Luego, te comentamos los métodos de sustitución de parámetros, que pueden ser por
VALOR o por REFERENCIA.
Finalmente, te contamos cómo es el ámbito de ejecución del algoritmo principal y de
las rutinas, en donde vimos las variables Globales y Locales de cada Función y
Procedimiento.
Estructuras lineales de datos

Introducción
En esta unidad nos proponemos presentarte nuevas estructuras de datos para

almacenar varios elementos. Te explicaremos qué son los arreglos y las
matrices y cómo utilizarlos. Además, te mostraremos qué son los
Registros y los archivos secuenciales, que podrás utilizar para almacenar
y recuperar tus datos.
cómo trabajar con arreglos, matrices, registros y cómo almacenar y
recuperar los datos en archivos secuenciales.
Supongamos que queremos calcular el promedio de edades de los alumnos de un

curso. Seguramente no tendrás ningún problema en resolverlo, ya que deberás
realizar un programa en el que el usuario vaya ingresando las edades, y por cada
edad ingresada se deberá acumular y contar. De esta manera tendrás la suma total
de las edades y la cantidad de alumnos, datos necesarios para obtener el promedio.
Ahora bien, le agregaremos un resultado más: queremos saber cuántos alumnos
superan la edad promedio.
Una vez que obtuviste el promedio de edades, deberás comparar cada edad para
determinar si supera la edad promedio, y en caso afirmativo, contarla
como una edad que supera la edad promedio.
Si la cantidad de alumnos es, por ejemplo, 500:
Por lo tanto necesitarás alguna otra estructura de datos para poder almacenar
todas las edades de los alumnos y poder consultarlas nuevamente. Es en
este momento donde te presentamos a los arreglos.
Un arreglo puede guardar varios datos asociados a un mismo nombre. Es una variable
que, en lugar de tener un único valor, tiene asociado una cantidad finita de valores. ¿Y
por qué finita? Porque al crear un arreglo debés indicar cuál es la cantidad de elementos
que vas a guardar en él.
Los arreglos también se denominan arreglos unidimensionales, vectores o arrays.
Para definir un arreglo, como te contamos antes, necesitás conocer la cantidad de

elementos que tendrá. De ahí surge que un arreglo es una estructura de datos estática,
ya que siempre tiene la misma cantidad de elementos.
SEUDOCÓDIGO
CONSTANTES
MAX = 10
TIPOS
T_ARR_ENTERO = arreglo de MAX de ENTEROS
VARIABLES
EDADES : T_ARR_ENTERO
CE : ENTERO
Para declarar un arreglo debemos tener definido un nuevo Tipo de Dato. En este
momento es donde tenemos que “crear” un tipo de dato para nuestro
programa que no se encuentra dentro de los tipos de datos simples. Estos
tipos de datos se conocen como Tipo de Dato definido por el Usuario, o
Tipo Abstracto de Datos (TDA, TAD).
Para declarar un arreglo debemos tener definido un nuevo Tipo de Dato. En este
momento es donde tenemos que “crear” un tipo de dato para nuestro programa que no
se encuentra dentro de los tipos de datos simples. Estos tipos de datos se conocen como
Tipo de Dato definido por el Usuario, o Tipo Abstracto de Datos (TDA, TAD).
En el ejemplo definimos un nuevo tipo, en la sección TIPOS, que
llamaremos T_ARR_ENTERO el cual será un arreglo de MAX elementos y cada elemento
será un ENTERO. En esta definición vemos que se declara un arreglo con la cantidad de
elementos que tendrá y el tipo de dato de cada uno de ellos. Es decir que estamos
definiendo un vector que tiene 10 elementos de tipo ENTERO.
La cantidad de elementos la pondremos en una Constante ya que nos facilitará la
modificación del algoritmo en caso de querer trabajar con un arreglo de enteros de otra
cantidad.
Finalmente, ya podremos declarar una Variable del nuevo Tipo de dato que llamaremos
EDADES (porque en nuestro arreglo, cada elemento será una edad).
Declaramos un nuevo Tipo de dato. El arreglo será una Variable de ese Tipo de dato.
La variable CE la utilizaremos para indicar la Cantidad de elementos lógica con la que

estamos trabajando en el arreglo, es decir los que tenemos en uso. Esta cantidad de
elementos debe ser menor o igual al Máximo, ya que un arreglo lo podemos usar como
un espacio para guardar MAX elementos.
A un arreglo lo llamaremos Arreglo vacío cuando CE = 0 (un vector sin elementos)
Siempre se deben cumplir las siguientes condiciones:
CE >= 0 Y CE <= MAX
Podemos definir un arreglo de la siguiente manera:

Un arreglo es es un conjunto finito de elementos del mismo tipo de dato y naturaleza
que ocupan posiciones contiguas de memoria y se encuentran asociados a un mismo
nombre en común.
• Conjunto finito: La cantidad de elementos de un arreglo es finita y se conoce en el

momento de definir el arreglo. No se pueden agregar o eliminar elementos, ya que un
arreglo tiene siempre la misma cantidad de componentes. Sin embargo, podemos
manejar un tope o cantidad lógica de elementos para indicar aquellos con los que
trabajaremos en el arreglo.
• Elementos del mismo tipo de dato y naturaleza: Todos los elementos son del mismo
tipo de dato. Además, los elementos deben representar el mismo dato. Por ejemplo, si
vamos a utilizar un arreglo para guardar edades de personas, todos los elementos serán
del tipo de dato ENTERO y además representarán una edad y no cualquier otro valor
como puede ser la cantidad de materias aprobadas.
• Ocupan posiciones contiguas de memoria: Los elementos se almacenan en la

memoria uno a continuación de otro. Como cada uno de los elementos ocupa el mismo
espacio, se puede acceder a cualquier elemento conociendo la posición de memoria del
primer elemento.
• Asociados a un mismo nombre: Un arreglo es una VARIABLE, por lo tanto tendrá un

solo nombre que estará asociado a un conjunto de valores. A cada uno de los elementos
se accede directamente a través de su posición, utilizando lo que llamaremos el Índice.
Como te contamos previamente, todos los elementos del arreglo están asociados a un
mismo nombre, pero tenemos una manera de acceder a cada uno de los elementos de
forma individual, y eso se hace a través del índice.
El índice es la posición relativa que tiene cada elemento en el arreglo.
Posición inicial
En nuestros ejemplos, el primer elemento comienza en la posición 1, es decir que para
acceder al primer elemento debemos acceder a la posición 1; para acceder al segundo
elemento accederemos a la posición 2 y así sucesivamente.
Acceso directo
Se puede acceder directamente a cada elemento particular por medio del índice sin
necesidad de tener que pasar por los elementos anteriores. Esto es lo que llamamos
acceso directo a cada elemento.
Como vimos antes, el acceso a cada elemento se realiza por su posición a través del
índice, y lo especificamos encerrando la posición entre corchetes ([]) de la siguiente
manera:
EDADES [POS]
Donde POS es la posición del elemento al que queremos acceder.
Recordemos que se tienen que cumplir las siguientes condiciones:
POS >= 1 Y POS <= CE

CE >= 0 Y CE <= MAX
Veamos un ejemplo para entender el acceso a cada elemento.....
SEUDOCÓDIGO
EDADES[1] <- 20
EDADES[2] <- 21
Mostrar (EDADES[1])
1. En la primera acción asignamos el valor 20 al elemento de la posición 1.

2. En la segunda acción asignamos el valor 21 al elemento de la posición 2
3. En la tercera acción mostramos el valor de la posición 1.
¿Qué valor se mostrará por pantalla?

Hacé clic en el botón para ver la respuesta.
El número 20.
Cuando trabajamos con arreglos es fundamental poder identificar el elemento y el valor

de ese elemento. El elemento está relacionado por la posición que ocupa (el índice),
mientras que el valor es el contenido (el dato) que se encuentra almacenado en esa
posición.
En el ejemplo tenemos que el elemento de la posición 1 tiene el valor 20, y el elemento
de la posición 2 tiene el valor 21.
Edades sub 2 es igual a 21.
• El valor del elemento de la posición 2 es 21.
• Si bien tenemos 10 elementos en EDADES, al haber cargado valores para los dos
primeros, diremos que el arreglo tiene 2 elementos. Por eso es que CE = 2.
• Las posiciones que debemos recorrer para acceder a los elementos deben ser 1 o 2, ya
que son las que tienen datos. De ahí surge la utilización de CE para acceder a todos los
elementos disponibles. CE será nuestro tope lógico para acceder a los elementos del
arreglo.
• Las posiciones a visitar serán las que se encuentren entre 1 y CE.
Veamos una rutina que utilizaremos para cargar un arreglo con los datos que
ingresa un usuario por teclado.
SEUDOCÓDIGO
PRE{}
Procedimiento CargarArreglo (ref A: T_ARR_ENTERO, ref CE: ENTERO)
VAR LOCALES
CONTINUAR : LOGICO
DATO : ENTERO
INICIO CE <- 0
RevisarFinDatos(CONTNUAR)
Mientras (CONTINUAR Y CE < MAX) Hacer
ObtenerEnteroPositivo(DATO)
A[CE] <- DATO
RevisarFinDatos(CONTINUAR)
FinMientras
Si (CONTINUAR) entonces
Finanormal()
finSi
FIN
POS {Carga el arreglo A con los datos que ingresa el usuario. Cada elemento es un
entero positivo >= 0. En caso de querer cargar más de MAX elementos finalizara la
ejecución}
Necesitaremos definir las siguientes rutinas adicionales:
SEUDOCÓDIGO - RUTINA 1
RE{}Procedimiento RevisarFinDatos (ref HAY_DATOS:LOGICO)
VAR LOCALES
RTA : CARACTERINICIO
Repetir
Mostrar (“¿Quiere ingresar datos? (s/n)”)
Ingresar (RTA)
Hasta que (RTA = ‘s’) O (RTA = ‘n’)
Si RTA = ‘s’ entonces
HAY_DATOS <- VERDADERO
Sino
HAY_DATOS <- FALSO
finsi
FIN
POS {HAY_DATOS es Verdadero si el usuario tiene más datos para ingresar}
SEUDOCÓDIGO - RUTINA 2
PRE{} Procedimiento ObtenerEnteroPositivo (ref N:ENTERO)
INICIO
Repetir
Mostrar (“Ingrese un número entero positivo >= 0”)
Ingresar (N)
Hasta que (N >= 0)
FIN
POS{N es un entero positivo >= 0}
Mostrar Arreglo
Ahora veremos una forma de mostrar todos los elementos junto con la posición. Este
procedimiento lo podremos utilizar cada vez que necesitemos mostrar todo un arreglo.
SEUDOCÓDIGO
PRE {CE >= 0, CE <= MAX} Procedimiento MostrarArreglo(ref A:T_ARR_ENTERO, val
CE:ENTERO)
VAR LOCALES
POS : ENTERO
INICIO
Para POS <- 1 hasta CE hacer
Mostrar (“Posicion:”, POS)
Mostrar (“Valor:”, A[POS])
Finpara
FIN
POS {Muestra todas las posiciones y cada uno de los elementos de A}
Analizaremos aquí un programa completo para cargar los elementos en un arreglo

y mostrarlos por pantalla.
SEUDOCÓDIGO
CONSTANTES
MAX = 10
TIPOS
T_ARR_ENTERO = arreglo de MAX ENTERO
VARIABLES
EDADES : T_ARR_ENTERO
CE : ENTERO
INICIO
CargarArreglo (EDADES, CE)
MostrarArreglo (EDADES, CE)
FIN
Ya sabemos que los parámetros los podemos pasar por Valor o por Referencia.
Ahora bien,
¿Qué sucede si pasamos un arreglo como parámetro en una rutina?
Si el arreglo pasa por valor se crea, en el ámbito de la rutina, el espacio suficiente para
almacenar el valor del parámetro actual. Es decir, que se tendrá que disponer en
memoria del espacio que ocupa todo el arreglo y además, ese espacio deberá estar
disponible de manera contigua.
Podemos decir que es un requerimiento importante, ya que un arreglo puede tener

muchos elementos, o bien, los elementos pueden ser complejos.
Por lo tanto, pasar un arreglo por valor necesitará mucho espacio de forma contigua,
algo que no siempre puede llegar a estar disponible, causando un error en tiempo de
ejecución por no haber memoria suficiente.
¿Cómo podemos evitar esto?
Recordemos que si pasamos un parámetro por referencia, en el ámbito de la rutina se

creará un puntero (una referencia) al parámetro actual. En este caso, al pasar un arreglo
por referencia, no será necesario tener disponible el área de memoria que ocupa todo el
arreglo, ya que solamente se necesita el puntero al vector. Por lo tanto, pasar un arreglo
por referencia será mucho más eficiente, veloz y ocupará menos espacio en memoria.
Debido a los requerimientos de memoria siempre pasaremos un arreglo por

Referencia.
Dado un arreglo de enteros (Max = 1000) se pide desarrollar una rutina que
devuelva la posición del elemento mayor en el arreglo. Si el mayor aparece
varias veces devolver la posición de la primera aparición del mismo.
PRE {CE >= 0; CE <= 1000}

Función PosicionMayor (ref A:T_ARR_ENTERO; valor CE:ENTERO)
VAR I, POSMAYOR : ENTERO
POSMAYOR <- 1
Para I <- 2 hasta CE Hacer
Si (A[I] > A[POSMAYOR]) entonces
POSMAYOR <- I
FinSi
FinPara
Devolver (POSMAYOR)
FinFunción
En esta sección te presentaremos qué es una matriz y cómo trabajar con ella. Para eso te
contamos que podemos clasificar a los arreglos según el número de dimensiones que
tienen. Así se tienen los:
Unidimensionales (vectores)
Bidimensionales (tablas o matrices)
Multidimensionales (tres o más dimensiones)
Una matriz es un arreglo en donde a cada elemento se accede por medio de dos
direcciones.
Al igual que con los arreglos unidimensionales, en este tipo de estructura de datos
también debemos definir su tamaño antes de utilizarla, con el agregado de la segunda
dimensión.
Ahora, te proponemos que veas el siguiente video sobre matrices:

CONSTANTES
MAXFILAS = 5
MAXCOLUMNAS = 10
TIPOS
T_MAT_ENTERO = matriz de MAXFILAS x MAXCOLUMNAS de ENTEROS
VARIABLES
MAT : T_MAT_ENTERO
Para declarar una matriz, del mismo modo que hicimos con los arreglos,
debemos tener definido un nuevo Tipo de Dato.
En el ejemplo, definimos un nuevo tipo, en la sección TIPOS, que
llamaremosT_MAT_ENTERO el cual será una matriz de MAXFILAS x
MAXCOLUMNAS y cada elemento será un ENTERO. Es decir que es una
matriz de 50 elementos de tipo ENTERO.
Finalmente, ya podremos declarar una Variable del nuevo Tipo de dato la cual
llamaremos MAT.
En el caso de las matrices, como es un arreglo con dos dimensiones, a cada elemento se
accede por medio de dos índices, el primero corresponde a la fila y, el segundo,
corresponde a la columna.
Veamos un ejemplo para entender el acceso a cada elemento:
SEUDOCÓDIGO
MAT[1,3] <- 20
MAT[2,5] <- 21
Mostrar (MAT[1,3])
1. En la primera acción, asignamos el valor 20 al elemento de la fila 1, columna 3.

2. En la segunda acción asignamos el valor 21 al elemento de la fila 2, columna 5.
3. En la tercera acción mostramos el valor del elemento de la fila1, columna 3.
¿Qué valor se mostrará por pantalla?

El número 20.
La posición de la fila y la columna se indica por medio de los dos números, teniendo en
cuenta que el primero corresponde a la fila y, el segundo, a la columna.
Se puede escribir de la siguiente manera:
MATRIZ [1,3] o bien MATRIZ [1][3]

hace referencia al mismo elemento, ubicado en la fila 1 columna 3.
rutina que utilizaremos para cargar una matriz con los datos que ingresa un usuario por
teclado.
SEUDOCÓDIGO
PRE{}
Procedimiento CargarMatrizPorFila (ref M: T_MAT_ENTERO, valor CF, CC: ENTERO)

F, C : ENTERO
INICIO
Para F <- 1 hasta CF Hacer
Para C <- 1 hasta CC Hacer
ObtenerEnteroPositivo(DATO)
M[F,C] <- DATO
FinPara
FinPara
FIN
POS {Carga la matriz M con los datos que ingresa el usuario. Cada elemento es un
entero positivo >= 0.}
En este ejemplo se cargan todas las posiciones de matriz y el orden de carga es por
filas. Es decir que el primer elemento que ingrese el usuario se cargará en la posición fila
1, columna 1. El segundo elemento que ingrese el usuario se cargará en la posición de la
fila 1, columna 2. Y así sucesivamente, recorriendo la matriz primero por la fila 1, cuando
llegue al último elemento de la fila 1, se pasará a la fila 2 …. Y así hasta recorrer y cargar
toda la matriz.
Mostrar Matriz
Del mismo modo que al cargar una matriz se puede recorrer por filas o por columnas, el
mostrar los elementos de una matriz también podemos hacer ambos recorridos.
Veamos ahora una rutina que muestra los elementos de una matriz, pero recorriéndola
por columnas. Es decir que el primer elemento que se muestra será el de la fila 1
columna 1, luego el de la fila 2, columna 1, y cuando finalice la columna 1 se pasará a la
columna 2. Y así hasta llegar hasta la última columna.
SEUDOCÓDIGO
PRE{}
Procedimiento MostrarMatrizPorColumna (ref M: T_MAT_ENTERO, valor CF, CC:ENTERO)

VAR LOCALES
F, C : ENTERO
INICIO
Para C <- 1 hasta CC Hacer
Para F <- 1 hasta CF Hacer
Mostrar M[F,C]
FinPara
FinPara
FIN
POS {Muestra los elementos de la matriz M recorriéndola por columnas.}
Veamos un programa completo para cargar los elementos en una matriz y mostrarla por
pantalla:
SEUDOCÓDIGO
CONSTANTES
MAXFILAS = 10
MAXCOLUMNAS = 10
TIPOS
T_MAT_ENTERO = matriz de MAXFILAS x MAXCOLUMNAS de ENTERO
VARIABLES
MAT : T_MAT_ENTERO
INICIO
CargarMatrizPorFila (MAT, MAXFILAS, MAXCOLUMNAS)
MostrarMatrizPorColumna (MAT, MAXFILAS, MAXCOLUMNAS)
FIN
Con el fin de lograr un control sobre el movimiento de personas en un edificio se

necesita registrar, para cada día del mes de marzo, cuántas personas se dirigen a cada
uno de los 14 pisos de edificio.
Ingresar los datos realizando las validaciones necesarias.
Luego, emitir:
a) Para cada piso y cada día, la cantidad de personas que ingresaron.
b) Cantidad total de personas ingresadas al edificio durante el mes.
c) Promedio diario de personas que ingresaron a cada piso.
SEUDOCÓDIGO
CONSTANTES
MAXFILAS = 14
MAXCOLUMNAS = 31TIPOS
T_MAT_ENTERO = matriz de MAXFILAS x MAXCOLUMNAS de ENTEROSVARIABLES
MAT : T_MAT_ENTEROINICIO
CargarMatrizPorFila (MAT, MAXFILAS, MAXCOLUMNAS) Para F <- 1 hasta MAXFILAS Hacer
Para C <- 1 hasta MAXCOLUMNAS Hacer
Mostrar ("Al piso:",F," el día:",C,"ingresaron:", M[F,C])
FinPara
FinPara
Mostrar ("En todo el mes ingresaron:",
TotalMatriz(MAT,MAXFILAS,MAXCOLUMNAS)
Para F <- 1 hasta MAXFILAS Hacer
Mostrar ("Al piso:",F," ingresaron en promedio:",
PromedioFila(MAT,F,MAXCOLUMNAS))
FinPara
FIN
PRE{C <> 0}
Función PromedioFila (ref M: T_MAT_ENTERO, valor F,C:ENTERO):REALVAR LOCALES

I, SUMA : ENTERO
INICIO
SUMA <- 0
Para I <- 1 hasta C Hacer
SUMA <- SUMA + M[F,I]
FinPara
Devolver (SUMA/C)
FIN
POS{Devuelve el promedio de los elementos de la fila F}
Supongamos que ahora además de pedir la edad de un alumno, también queremos

saber el nombre y la cantidad de materias aprobadas. Es decir que por cada alumno
tendremos tres valores que guardaremos en tres variables distintas. En el caso en que se
necesite hacer un procedimiento que imprima los datos de cada alumno, tendrá que
tener esos tres datos como parámetros.
Hasta ahora no habrás encontrado ninguna dificultad en este problema, pero qué
sucede si te decimos que, además de los datos mencionados, también queremos
guardar otros valores, como, por ejemplo, el número de documento, el sexo, la cantidad
de materias que está cursando…. Tendrás que agregar todos esos datos en la lista de
parámetros de cada rutina que quiera trabajar con los datos de un alumno. Como habrás
notado, se estará haciendo más complejo el algoritmo, y hasta cierto punto, difícil para
entenderlo y hasta para probarlo.
Evidentemente necesitamos una nueva estructura de datos para poder guardar de forma
más apropiada estos valores. Es en este momento donde necesitamos utilizar los
Registros.
Veamos cómo definimos un registro para guardar los datos de un alumno:
TIPOS
T_REG_ALUMNO = REGISTRO
NOMBRE : CADENA
EDAD : ENTERO
CANT_MAT_APROB : ENTERO
FIN REGISTRO
VARIABLES
ALUMNO : T_REG_ALUMNO
Para definir un Registro debemos definir un nuevo tipo de dato que indique los
elementos que contiene y cuáles serán sus nombres.
En este ejemplo estamos definiendo un nuevo tipo de datos que se
llama T_REG_AGLUMNO como un Registro. Este Registro tiene tres campos que son:
Nombre, de tipo de dato Cadena; Edad, de tipo de dato Entero y Cant_mat_aprob que
también es de tipo de dato Entero.
Luego definimos una variable que se llama ALUMNO que es un Registro del tipo de
dato T_REG_ALUMNO. Es decir, que la variable ALUMNO guardará tres valores bajo su
mismo nombre lógico.
Uno de los principales motivos por el que definimos Registros es para asociar bajo una
misma variable a un conjunto de elementos que representan el mismo concepto.
En el ejemplo que te estamos presentando, esos tres valores, el nombre, la edad y la
cantidad de materias aprobadas, en su conjunto representan los datos de un alumno,
es decir, en otras palabras que un alumno está formado por esos tres valores.
Seguramente te estarás preguntando que, si bien los tres elementos están asociados a
un mismo nombre lógico, debe haber alguna manera de poder acceder a cada dato. Esa
manera es utilizando el nombre de cada elemento. Cada elemento del Registro se
denomina “campo”.
En nuestro ejemplo, el registro ALUMNO tiene tres campos. Y podrás acceder a cada
campo por medio del operador punto “.” y el nombre del campo.
Te mostramos un ejemplo de cómo utilizar los registros...
SEUDOCÓDIGO
INICIO
Mostrar (“Ingrese la edad del alumno”)
Ingresar (ALUMNO.EDAD)
FIN
Entonces:
 ALUMNO -> Nombre de Registro

 "." -> Operador punto
 EDAD -> Nombre del Campo
Para acceder a la EDAD debemos indicarlo con el nombre de la

variable ALUMNO seguido del operador punto. y luego el nombre del campo al que
queremos acceder, en este caso EDAD.
Del mismo modo, si queremos asignar el nombre “Juan” como nombre del alumno
debemos hacerlo de siguiente manera:
ALUMNO.NOMBRE <- "Juan"
Una de las ventajas de utilizar registros es que se pueden agrupar en una misma variable
todos los datos relacionados lógicamente. De esta manera, podemos manejar la
abstracción para el ingreso y la salida de los datos.
Por ejemplo, si estamos trabajando con datos de alumnos, lo más simple sería pensar en
una entidad ALUMNO como un único conjunto de datos (ocultando los datos que tiene
un alumno).
Siguiendo con este concepto, podemos desarrollar los siguientes procedimientos.

SEUDOCÓDIGO
PRE{}
Procedimiento ObtenerAlumno (ref A:T_REG_ALUMNO)
INICIO
ObtenerNombre(A.NOMBRE)
ObtenerEdad(A.NOMBRE)
ObtenerCantidadMateriasAprobadas(CANT_MAT_APROB)
FIN
POS{A está formado por los datos del alumno que cargó el usuario}
PRE{}
Procedimiento MostrarAlumno (valor A:T_REG_ALUMNO)

INICIO
Mostrar (“Nombre:”, A.NOMBRE)
Mostrar (“Edad:”, A.EDAD)
Mostrar (“Cant. De materias aprobadas”, A.CANT_MAT_APROB)
FIN
POS{Muestra por pantalla los datos del alumno A}
En el procedimiento ObtenerAlumno, habrás notado que está pasando el parámetro de

tipo registro T_REG_ALUMNO. Esto nos permite simplificar y abstraer el tipo de dato, ya
que estamos manejando un alumno como concepto de una entidad (sin importar los
datos que tenga).
De esta manera será mucho más simple el mantenimiento, ya que si querés agregar o
eliminar datos al alumno, solo vas a tener que modificar la estructura del registro. Las
especificaciones de las rutinas que utilizan estos registros no se ven modificadas ya que
siempre se estará pasando como parámetro un registro.
Ingresar los siguientes datos de los alumnos de un curso: nombre, documento y

promedio académico. El máximo es de 250 alumnos Mostrar el listado de
alumnos cuyo promedio es mayor o igual al promedio general de todos
los alumnos.
SEUDOCÓDIGO
CONSTANTES
MAX = 250
TIPOS
T_REG_ALUMNO = REGISTRO
NOMBRE: CADENA
DOCUMENTO: ENTERO
PROMEDIO: REAL
FIN REGISTRO
T_ARR_ALUMNOS = arreglo de MAX de T_REG_ALUMNO
VARIABLES
CURSO : T_ARR_ALUMNOS
CE,I : ENTERO
INICIO CargarAlumnos (CURSO,CE)
PROM <- PromedioArreglo(CURSO,CE)
Para I <- 1 hasta CE hacer
Si CURSO[I].PROMEDIO >= PROM entonces
MostrarAlumno(CURSO[I])
FinSi
FinParaFIN
Procedimiento CargarAlumnos (ref A: T_ARR_ALUMNOS, ref CE: ENTERO)

VAR LOCALES
CONTINUAR : LOGICO
ALUMNO : T_REG_ALUMNO
INICIO
CE <- 0
Mientras (CONTINUAR Y CE < MAX) Hacer
ObtenerAlumno(ALUMNO)
CE <- CE + 1
A[CE] <- ALUMNO
RevisarFinDatos(CONTINUAR)
FinMientras
Si (CONTINUAR) entonces
Finanormal()
finSi
FIN
POS {Carga el arreglo A con los datos que ingresa el usuario. Cada elemento es un
registro T_REG_ALUMNO. En caso de querer cargar más de MAX elementos finalizara la
ejecución}
Procedimiento ObtenerAlumno (ref A: T_REG_ALUMNO)

INICIO
Mostrar (“Ingrese el nombre:”)
Ingresar (A.NOMBRE)
Mostrar (“Ingrese el documento:”)
Ingresar (A.DOCUMENTO)
Repetir
Mostrar (“Ingrese el promedio:”)
Ingresar (A.PROMEDIO)
Hasta que A.PROMEDIO >= 0
FIN
Procedimiento MostrarAlumno (valor A: T_REG_ALUMNO)

INICIO
Mostrar (“Datos del alumno:”)
Mostrar (“Nombre:”,A.NOMBRE)
Mostrar (“Documento:”,A.DOCUMENTO)
Mostrar (“Promedio:”,A.PROMEDIO)
FIN
PRE{C <> 0}
Función PromedioArreglo (ref C: T_ARR_ALUMNOS, valor C:ENTERO):REAL

VAR LOCALES
I, SUMA : ENTERO
INICIO
SUMA <- 0
Para I <- 1 hasta C Hacer
SUMA <- SUMA + C[I]
FinPara
Devolver (SUMA/C)
FIN
POS{Devuelve el promedio de los elementos del arreglo C}
Hasta ahora hemos trabajado con estructuras de datos que residían en la memoria
principal, por lo general los datos se almacenaban en arreglos u otras estructuras de
datos en memoria dinámica que eran referenciada por apuntadores.
Pero.....
¿qué sucede cuando finaliza la ejecución de un programa?
Los datos de la memoria principal se eliminan y ese espacio queda disponible para otro
programa. Seguramente estarás pensando que debe haber alguna manera para guardar
los datos y que se vuelvan a utilizar en otros programas. Y es ahí en donde aparece la
necesidad de contar con Archivos.
Un archivo es una colección de registros lógicamente relacionados.
Recordá que un registro es una estructura de campos o de elementos de información

lógicamente relacionados. Por lo general, todos los registros de un archivo tienen un
mismo formato, aunque hay archivos especiales que tienen múltiples tipos de registros.
Es importante destacar que los registros almacenados en un mismo archivo guardan una
relación entre ellos por el hecho de pertenecer al mismo archivo.
Razones para utilizar archivos

Hay varias buenas razones para organizar los datos en una misma estructura de archivo,
entre las principales te podemos mencionar:
• Para almacenar datos independientemente del programa que los vaya a procesar. Un
archivo proporciona un medio de almacenamiento permanente, que se mantiene una
vez finalizado el programa.
• Para almacenar grandes volúmenes de información. La memoria principal es muy
limitada y puede almacenar pocos datos.
• Para acceder a una parte de los datos almacenados. Si el programa debe acceder
solamente a algunos datos no es necesario tener cargados todos los datos en la
memoria principal.
• Para reducir el costo de almacenamiento. La memoria secundaria es mucho más
económica que la memoria principal.
Organización de archivos
La técnica utilizada para representar y almacenar registros en un archivo es llamada
organización de archivos. Las cuatro técnicas fundamentales de organización de archivos
son
• Secuencial
• Relativa
• Secuencial indexado
• Multi llave
La organización más apropiada para un archivo en particular está determinada por las
características operacionales del medio de almacenamiento utilizado y por la naturaleza
de las operaciones a ejecutar sobre los datos. En esta materia nos ocuparemos de los
Archivos Secuenciales.
A continuación, veremos con más detalle, en qué consisten las Operaciones sobre
Archivos...
Las operaciones básicas que se ejecutan sobre archivos secuenciales son las siguientes:
 Asignación
 Apertura y Creación
 Inserción de registros
 Consulta
 Cierre
Veamos a continuación cada una de ellas...
(hacé clic sobre cada operación básica para ver su descripción)
Asignación
Cuando se hace referencia a un archivo en una unidad física se entiende a un conjunto
particular de bytes almacenados allí. El archivo tiene una existencia física en una unidad
de almacenamiento que, a su vez, puede tener miles de archivos.
Desde el punto de vista de un programa, la idea de archivo es distinta. El concepto de
archivo es de archivo lógico, ya que el programa realiza operaciones sobre el archivo
lógico, pero no las aplica directamente sobre el archivo físico. A nivel de aplicación el
programa trabaja con el archivo lógico, mientras que el encargado de realizar las
operaciones sobre los bytes del archivo físico es el Sistema Operativo. Debido a eso
hay que establecer una relación entre el archivo lógico, que será manejado por el
programa, y el archivo físico, al cual accede el S.O. Dicha vinculación entre el archivo
lógico y el archivo físico es la operación ASIGNACIÓN
asignar (archivoLogico, “archivo físico”)
Apertura y Creación
Una vez que se tiene un identificador de archivo lógico enlazado con un archivo físico, es
necesario declarar lo que se desea hacer con él. En general se tienen dos opciones
1. Abrir un archivo existente
abrir (archivoLogico)
La apertura de un archivo implica que está listo para que el programa lo use. El usuario
estará colocado al principio del archivo y listo para leer. El contenido del archivo no se
altera con la operación ABRIR.
2. Crear un archivo nuevo, eliminando cualquier contenido ya existente en el archivo

físico
crear (archivoLogico)
Crear un archivo es también abrirlo en el sentido de que estará listo para usarse después
de crearlo. Ya que un archivo recién creado no tiene contenido, el único uso que tiene
sentido al inicio es la escritura
Consulta
Dado un archivo lógico podés obtener el dato actual para consultarlo.
leer (archivoLogico, dato)
Al consultar también tenés que saber si ya llegaste el final del archivo. Y para eso
podésusar la siguiente función que devuelve VERDADERO si se alcanzó el final y FALSO
en caso contrario.
fin (archivoLogico)
Actualización
Dado un dato, se agrega al final del contenido del archivologico:
grabar(archivoLogico,dato)
Cierre
Cuando cerrás un archivo, el nombre lógico del archivo queda disponible para usarse
con otro archivo. Además, el cierre del archivo de escritura asegura que todo se ha
escrito correctamente.
cerrar (archivoLogico)
Estructuras lineales de datos
Lectura y escritura de archivos
La forma de trabajar con los archivos secuenciales será de lectura o de escritura. Es
decir que con un archivo secuencial, se puede abrir para leerlo o bien crearlo en blanco
para almacenar datos en él.
Cuando trabajás con un archivo de lectura, el primer registro que se lee es el que se
encuentra al comienzo del archivo, luego se lee el segundo, y así sucesivamente hasta
llegar hasta el último registro, pasando por todos los anteriores.
En el siguiente ejemplo te presentamos cómo trabajar con un archivo secuencial de

lectura. En donde leemos todos los registros desde el primero hasta el último:
SEUDOCÓDIGO
VARIABLESARCH : Archivo de T_REG
REG : T_REG
Abrir (ARCH)
Leer (ARCH,REG)
Mientras NO Fin(ARCH) Hacer
TratarRegistro(REG)
Leer (ARCH,REG)
FinMientras
Cerrar(ARCH)
Cuando trabajás con un archivo de escritura, al crear el archivo siempre se crea sin datos.
Luego se guardan los registros de a uno por vez. El registro que se agrega siempre se
almacena al final del archivo. De esta manera, en el archivo, se mantienen los datos en el
orden en que fueron almacenados.
En el siguiente ejemplo te presentamos cómo trabajar con un archivo secuencial de

escritura.
SEUDOCÓDIGO
VARIABLES
ARCH : Archivo de T_REG
REG : T_REG
CONTINUAR : LOGICO
Crear(ARCH)
Mientras (CONTINUAR) Hacer
ObtenerReg(REG)
Grabar (ARCH,REG)
FinMientras
Cerrar(ARCH)
Desarrollar un programa que permita ingresar los apellidos y los sueldos de

los empleados de una empresa y que los grabe en un archivo de
registros. Luego generar un informe que, a partir de los datos del
archivo creado, los muestre por pantalla y finalmente emita el total
de sueldos a pagar.
SEUDOCÓDIGO
TIPOS
T_REG_EMPLEADO = REGISTRO
APELLIDO:CADENA
SUELDO:REAL
FIN REGISTROVARIABLES
ARCH_EMPLEADOS : Archivo de T_REG_EMPLEADO
CONTINUAR : LOGICO
EMPLEADO : T_REG_EMPLEADO
TOTAL : REAL INICIO Crear(ARCH_EMPLEADOS)
ObtenerEmpleado(EMPLEADO)
Grabar (ARCH_EMPLEADOS,EMPLEADO)
FinMientras
Cerrar(ARCH_EMPLEADOS)
TOTAL <- 0
Abrir (ARCH_EMPLEADOS)
Leer (ARCH_EMPLEADOS,EMPLEADO)
Mientras NO Fin(ARCH_EMPLEADOS) Hacer
MostrarEmpleado (EMPLEADO)
TOTAL <- TOTAL + EMPLEADO.SUELDO
Leer (ARCH_EMPLEADOS,EMPLEADO)
FinMientras
Cerrar(ARCH_EMPLEADOS)
Mostrar (“Total de sueldos a pagar:”, TOTAL)
FIN
En esta unidad te presentamos las ESTRUCTURAS DE DATOS LINEALES, con las cuales
podrás almacenar un conjunto de elementos agrupados bajo una misma variable.
Te presentamos los VECTORES, en donde podés guardar, en una misma variable, un

conjunto finito de elementos del mismo tipo de dato y naturaleza. Luego te comentamos
cómo trabajar con arreglos de dos dimensiones, que también se denominan MATRICES.
Además, te mostramos el tipo de dato REGISTRO, con el cual podrás agrupar un

conjunto de CAMPOS de distinto TIPO DE DATO que pertenezcan a una misma entidad.
Finalmente, te mostramos cómo almacenar tus registros de forma permanente y luego

cómo recuperar esos datos. Para eso usamos los ARCHIVOS SECUENCIALES que son un
tipo de archivo, no veremos los otros tipos en esta materia.
Estructuras de datos definidas por el usuario

Introducción
En esta unidad nos proponemos presentarte nuevas estructuras de datos para almacenar
varios elementos. Te explicaremos qué son las pilas y las colas y cómo es el
funcionamiento de estas estructuras de datos.
Además, te mostraremos qué son las listas enlazadas y cómo podrás hacer uso de ellas
en tus programas.
¡¡Comenzamos la última unidad!!

En las unidades anteriores trabajaste con nuevos tipos de datos para almacenar un
conjunto de valores. A ese conjunto de valores se podía acceder de forma directa a
través de los índices, es decir que podías consultar cualquier elemento y agregar o
eliminar un dato en cualquier posición de la estructura.
Te traemos el mapa síntesis de la unidad anterior para que lo recuerdes y puedas

organizar al final de esta unidad los nuevos conceptos dentro de este mapa.
Así, esta unidad veremos cómo trabajar también con un conjunto de datos, pero esta vez
con pilas, colas y listas. Estas estructuras de datos se consideran ordenadas porque el
acceso se realiza dependiendo del orden en el que se ingresaron los datos.
A continuación, te contaremos cómo es el funcionamiento de cada una de ellas.....
Seguramente en tu ropero guardas en algún estante tus remeras o sweaters. Ahora bien,
supongamos que tenés 3 remeras ubicadas en este orden, la azul, la blanca y la negra,
de modo que la remera que está arriba es la negra. Si querés agregar una nueva remera,
supongamos una de color verde, al estante, ¿en dónde la ubicarías?
Seguramente arriba de la remera negra. Y ahora la nueva remera es la que se encuentra
en la cima.
¿Qué pasa si querés sacar la remera blanca? ¿Podés sacarla directamente?
No, porque arriba de la remera blanca están la negra y la verde. Por lo tanto, primero
debés sacar la verde, luego la negra y recién ahí podrás sacar la blanca.
La forma de agregar y quitar las remeras es lo que se define como el funcionamiento de

una estructura de datos Pila. En una pila, todos los elementos se agregan y se quitan
desde la cima.
El nombre Pila surge precisamente de los casos que suceden en la vida diaria en donde
se “apilan” objetos. Podemos encontrar numerosos casos de pilas con esta
funcionalidad, por ejemplo, una pila de platos, el tráfico de una calle sin salida, etc.
Una Pila es un conjunto finito de elementos del mismo tipo de dato donde agregar o
eliminar elementos se realiza solamente desde un extremo de la estructura, que
llamaremos cima de la pila
La Pila es una estructura ordenada porque sus componentes están ordenados de acuerdo al
tiempo que llevan en la pila. Debido a que los elementos se insertan y eliminan solo por el
extremo de la Pila, se dice que es una estructura de tipo LIFO (Last In First Out), el último
elemento en ingresar es el primero en salir.

Operadores de Pilas
Hasta el momento te explicamos cómo es la funcionalidad de una estructura Pila, que
corresponde a la definición del tipo de dato abstracto. Además, debemos utilizar un
conjunto de operadores para poder acceder y manipular los elementos de la estructura.
Una Pila es una estructura cambiante, ya que se pueden agregar y eliminar elementos.
Para comenzar a usar una Pila debemos crearla en un estado vacío. Del mismo modo,
tendrás la necesidad de evaluar el estado antes de agregar elementos para saber si la
pila tiene lugar o se encuentra llena.
Todas estas acciones, necesarias para el funcionamiento de una pila, se encuentran

implementadas en el siguiente conjunto de operadores.
SEUDOCÓDIGO
TIPO
TPILA = Pila de TDATO
Función Pvacía (ref P: TPILA): LÓGICO
Función Pllena (ref P: TPILA): LÓGICO
Procedimiento Pcrear (ref P: TPILA)
Procedimiento Pponer (ref P: TPILA; Valor X: TDATO)
Procedimiento Psacar (ref P: TPILA; Ref X: TDATO)
Recordá que las funciones son rutinas que devuelven un único resultado asociado a su
nombre. En cambio, los procedimientos, son rutinas que pueden devolver uno, muchos
o ningún resultado, y todos ellos vuelven a través de los parámetros de salida.
Los parámetros que pasan por valor son parámetros de entrada, mientras que
los parámetros de salida son aquellos que se sustituyen por referencia.
(hacé clic sobre cada operador para ver su descripción)
Pvacia
Devuelve verdadero si la pila no tiene ningún elemento.
Pllena
Devuelve verdadero si la pila agotó su capacidad, esto quiere decir no hay espacio para
agregar ningún otro elemento.
Pcrear
Es el operador de creación. Prepara la estructura para comenzar a trabajar con ella.
Luego de crear la estructura, la pila se encuentra vacía.
Pponer
Tiene como precondición que la pila no esté llena. Agrega a la pila el elemento X de tipo
TDATO.
Psacar
Tiene como precondición que la pila no esté vacía. Quita el dato que se encuentra en la
cima y lo almacena en X
A continuación, te presentamos un ejemplo...
Te presentamos un ejemplo para que veas cómo es el funcionamiento de una pila y

cómo utilizar los operadores.
Ingresar un conjunto de números enteros y mostrarlos por pantalla en el orden

inverso al que se ingresaron.
SEUDOCÓDIGO
TIPOS
TDATO = ENTERO
TPILA = PILA de TDATOVARIABLES
PILA : TPILA
DATO : TDATO
CONTINUAR : LOGICOINICIO
Pcrear(PILA)
Mientras (CONTINUAR Y NO Pllena(PILA)) Hacer
ObtenerEntero(DATO)
Pponer(PILA,DATO)
FinMientras Mientras (NO Pvacia(PILA)) Hacer
Psacar(PILA,DATO)
Mostrar(DATO)
FinMientrasFIN
Para declarar una Pila debemos tener definido un nuevo Tipo de Dato.
Hacé clic y te explicaremos qué declaramos en cada línea.

Como vimos en la unidad anterior, que estamos precisando un Tipo de Dato definido
por el Usuario, o Tipo Abstracto de Datos (TDA, TAD).
En el ejemplo definimos un nuevo tipo, en la sección TIPOS, que llamaremos TPILA, que
será una Pila en donde los elementos son del Tipo TDATO. Del mismo modo, TDATO es
un Tipo de dato definido por el usuario, y está formado por un ENTERO.
Luego definimos dos variables: PILA, que será la variable en donde se almacenará
nuestra estructura PILA; y DATO, que será el elemento de la pila que vamos a apilar y a
desapilar.
Ahora pasemos al algoritmo principal. Lo primero que se realiza es crear la pila, con el
operador pcrear. Luego se invoca al procedimiento RevisarFinDatos, que explicamos en
la Unidad anterior.
En este momento ya estamos listos para apilar los elementos en la pila, es por eso que
comienza el ciclo Mientras, que va a continuar mientras el usuario quiera ingresar datos
y además, la pila tenga espacio libre para ese elemento (es decir que NO está llena).
En este ciclo se pide le dato al usuario y luego lo guarda en la pila utilizando el

operador pponer.
Cuando sale del ciclo, ya se encuentran todos los elementos cargados en la pila.
Como es una pila, el último elemento que se ingresó es el primero que saldrá, por lo
tanto, es una estructura ideal para invertir el orden de los elementos. Lo que falta hacer,
ahora, es ir desapilando los elementos y mostrarlos. Esto se realiza con el segundo ciclo
Mientras, ya que mientras la Pila NO está vacía (es decir que hay algún elemento) se saca
el elemento de la cima, con el operador psacar y luego se muestra.
De esta manera utilizamos una Pila para guardar los elementos y mostrarlos desde el
último al primero.
Leer un número entero e imprimir el mismo número, pero con los millares
separados con un “.”.
Por ejemplo: Se lee 123456 y se imprime 123.456.
SEUDOCÓDIGO
TIPOS TDATO = CARACTER TPILA = PILA de TDATOVARIABLES
PILA : TPILA
DATO : TDATO
NUM,CANT : ENTERO
INICIO Pcrear(PILA)
ObtenerEntero(NUM)
CANT <- 0
Mientras (NO Pllena(PILA) Y NUM > 0 ) Hacer
Pponer(PILA, Carácter(NUM RESTO 10))
CANT <- CANT + 1
NUM <- NUM DIV 10
Si (CANT = 3 y NUM > 0) entonces
Pponer(PILA, “.”)
CANT <- 0
Finsi
FinMientras
Mientras (No Pvacia(PILA)) Hacer
Psacar(PILA, DATO)
Mostrar (DATO)
FinMientras
FINFUNCIÓN Caracter (valor N: ENTERO) : CARACTERVAR
CAR : CARACTER
INICIO
Según N hacer
1 : CAR <- “1”
2 : CAR <- “2”
3 : CAR <- “3”
4 : CAR <- “4”
5 : CAR <- “5”
6 : CAR <- “6”
7 : CAR <- “7”
8 : CAR <- “8”
9 : CAR <- “9”
0 : CAR <- “0”
FinSegún
Devolver CAR
FIN
COLA
Funcionalidad
Ahora te comentamos otro ejemplo de la vida diaria y para eso te proponemos que
pienses en las colas de espera de un supermercado o los clientes de un Banco que
esperan ser atendidos.
Cuando llega un nuevo cliente, se ubica en la fila, pero no en cualquier lugar, se ubica al
final. En cambio, cuando el empleado se desocupa y llama al próximo cliente, ¿Quién es
la persona en ser atendida? Es aquella que se encuentra al comienzo de la cola.
Habrás notado que las personas ingresan y salen por los extremos opuestos de la fila.
Esta forma en la cual ingresan y salen las personas de las filas es lo que se define como
el funcionamiento de una estructura de datos Cola.
En una cola, los elementos se agregan por un extremo (el final) y se sacan desde el otro
extremo (el principio o frente).
Podemos encontrar numerosos casos de colas con esta funcionalidad.
Ahora, te pedimos que pienses, en un contexto informático, la gestión de los trabajos de

una impresora de red:
Seguramente nos estarás respondiendo que lo hace mediante una cola, ya que todos los
archivos a imprimir se van guardando y se irán imprimiendo según el orden de llegada.
¿Cómo definimos una Cola?

Definición
Una Cola es un conjunto finito de elementos del mismo tipo de dato donde los
elementos se agregan en un extremo, denominado final, y se eliminan por el otro
extremo, denominado frente.
Del mismo modo que una Pila, una Cola es una estructura ordenada porque sus
componentes están ordenados de acuerdo al tiempo que llevan en la cola. Debido a que
los elementos se insertar y eliminan por extremos opuestos, se dice que una Cola es una
estructura de tipo FIFO (First In First Out), el primer elemento en ingresar es el primero
en salir.

Operadores de Cola
Hasta el momento te explicamos cómo es la funcionalidad de esta estructura Cola, que
corresponde a la definición del tipo de dato abstracto. Ahora conoceremos cómo
utilizar un conjunto de operadores para poder acceder y manipular los elementos de la
estructura.
Todas las acciones necesarias para el funcionamiento de una cola se encuentran

implementadas en el siguiente conjunto de operadores:
SEUDOCÓDIGO
TIPO
TCOLA = Cola de TDATO
Función Cvacía (ref C: TCOLA): LÓGICO
Función Cllena (ref C: TCOLA): LÓGICO
Procedimiento Ccrear (ref C: TCOLA)
Procedimiento Cponer (ref C: TCOLA; Valor X: TDATO)
Procedimiento Csacar (ref C: TCOLA; Ref X: TDATO)
(hacé clic sobre cada operador para ver su descripción)

Cvacia
Devuelve verdadero si la cola no tiene ningún elemento.
Cllena
Devuelve verdadero si la cola agotó su capacidad, esto quiere decir no hay espacio para
Ccrear
Luego de crear la estructura, la cola se encuentra vacía.
Cponer
Tiene como precondición que la cola no esté llena. Agrega a la cola el elemento X de
tipo TDATO.
Csacar
Tiene como precondición que la cola no esté vacía. Quita el dato que se encuentra en la
cima y lo almacena en X
Un ejemplo de Cola
Te presentamos un ejemplo para que veas cómo es el funcionamiento de una cola y
cómo utilizar los operadores.
Leer un conjunto de caracteres y luego ingresar un número N positivo menor o

igual que la cantidad de ese conjunto de caracteres ingresados. Informar los
primeros N caracteres. Ej. se lee “Técnicas de Programación” y el número 8, se debe
imprimir “Técnicas”.
SEUDOCÓDIGO
TIPOS
TDATO = CARACTER
TCOLA = COLA de TDATOVARIABLES
COLA : TCOLA
DATO : TDATO
CANT, N : ENTERO
CONTINUAR : LOGICOINICIO
Ccrear(COLA)
CANT <- 0
Mientras (CONTINUAR Y NO Cllena(COLA)) Hacer
ObtenerCaracter(DATO)
Cponer(COLA,DATO)
CANT <- CANT + 1
FinMientras Repetir
Mostrar ("Ingrese un entero positivo menor o igual a ", CANT)
Ingresar (N)
Hasta que (N >= 0) Y (N <= CANT)
Para I desde 1 hasta N hacer
Csacar(COLA,DATO)
Mostrar(DATO)
FinPara
FIN
Para declarar una Cola debemos tener definido un nuevo Tipo de Dato.
Hacé clic y te explicamos qué declaramos en cada línea...
En el ejemplo definimos un nuevo tipo, en la sección TIPOS, que llamaremos TCOLA, el

cual será una Cola en donde los elementos son del Tipo TDATO. Del mismo
modo, TDATO es un Tipo de dato definido por el usuario, y está formado por un
CARACTER.
Luego definimos la variable COLA, donde se almacenará nuestra estructura COLA; DATO,
que será el elemento de la cola que vamos a poner y a sacar; y CANT que será el
contador de caracteres que ingresó el usuario.
Ahora pasemos al algoritmo principal. Lo primero que se realiza es crear la cola, con el
operador ccrear. Luego se inicializa el contador de caracteres en 0 y se invoca al
procedimiento RevisarFinDatos. Ahora pasamos el ciclo con el cual vamos a cargar en
una cola todos los elementos que vaya ingresando el usuario, utilizando el operador
Cponer.
Cuando el usuario finaliza el ingreso de datos, se procede a pedir un entero N que sea
menor a la cantidad de los datos, para poder quedarnos con esos N primeros. Luego,
vamos sacando de la cola, con el operador Csacar, la cantidad de elementos que nos
indicó el usuario. Como los elementos de la cola salen por el frente, el primero que
mostramos es el primero que ingresó. De esa manera, utilizamos una cola para mostrar
los elementos en el mismo orden en que fueron ingresados.
Leer un número entero e informar el reverso.

Por ejemplo: Si el número es 123456, el reverso es 654321
SEUDOCÓDIGO
TIPOS
TDATO = ENTERO
TCOLA = COLA de TDATOVARIABLES
COLA : TCOLA
DATO : TDATO
NUM : ENTERO INICIO
Ccrear(COLA)
ObtenerEntero(NUM)
Mientras (NUM >0 Y NO Cllena(COLA)) Hacer
Cponer(COLA,NUM RESTO 10)
NUM <- NUM DIV 10
FinMientras
Mientras (NO Cvacia(COLA)) Hacer
Csacar(COLA,DATO)
Mostrar(DATO)
FinMientrasFIN
Funcionalidad
Ahora te comentamos otro ejemplo de la vida diaria y para eso te proponemos que
pienses en una lista de compras. Seguramente, cuando vas al supermercado, o a realizar
una compra de muchos productos, previamente los escribís en un pape
Aquí hay que escribir el contenido colapsable.
Seguramente nos estarás respondiendo que vas escribiendo los productos a medida que
recordás qué necesitás comprar. Luego vas agregando elementos en cualquier lugar,
puede ser al final, al comienzo, o en cualquier ubicación. Por otro lado, a medida que vas
comprando esos productos, vas tachando o eliminando los productos en cualquier
orden. Es decir que en esa lista vas agregando o eliminando elementos, sin importar en
qué lugar se encuentren.
En una lista, los elementos se agregan o eliminan en cualquier ubicación.
Definición
Una Lista es un conjunto finito de elementos del mismo tipo de dato donde los
elementos tienen un orden de sucesión lineal. Es decir, que cada elemento, excepto
el último, tiene un sucesor.

Operadores de Listas
Hasta el momento te explicamos cómo es la funcionalidad de una estructura Lista, que
corresponde a la definición del tipo de dato abstracto. Además, debemos utilizar un
conjunto de operadores para poder acceder y manipular los elementos de la estructura.
Todas las acciones necesarias para el funcionamiento de una lista se encuentran

implementadas en el siguiente conjunto de operadores:
SEUDOCÓDIGO
TIPO
TLISTA = Lista de TDATO
Función Lvacía (ref C: TLISTA): LÓGICO
Función Lllena (ref C: TLISTA): LÓGICO
Procedimiento Lcrear (ref L: TLISTA)
Procedimiento Linsertar (ref L:TLISTA; Val X:TDATO, POS:ENTERO)
Procedimiento Linsertarprincipio (ref L:TLISTA; Val X:TDATO)
Procedimiento Linsertarfinal (ref L:TLISTA; Val X:TDATO)
Función LEstaenlista (ref L: TLISTA; Valor X: TDATO): LÓGICO
Función Lbuscar (ref L: TLISTA; Valor X: TDATO): ENTERO
Función Lsiguiente (ref L: TLISTA; Valor POS: ENTERO): ENTERO
Función Lprimero (ref L: TLISTA): ENTERO
Procedimiento Lsacar (ref L:TLISTA; val POS:ENTERO; ref X:TDATO)
Hacé clic sobre cada operador para ver su descripción.
Lvacia
Devuelve verdadero si la lista no tiene ningún elemento.
Lllena
Devuelve verdadero si la lista agotó su capacidad, esto quiere decir no hay espacio para
Lcrear
Luego de crear la estructura, la lista se encuentra vacía
Linsertar
Tiene como precondición que la lista no esté llena y pos es una posición válida.
Agrega a la lista el elemento X de tipo TDATO en la posición POS
Linsertarprincipio
Tiene como precondición que la lista no esté llena.
Agrega al principio de la lista el elemento X de tipo TDATO.
Linsertarfinal
Tiene como precondición que la lista no esté llena.
Agrega al final de la lista el elemento X de tipo TDATO.
Lestarenlista
Devuelve verdadero si el elemento X se encuentra en la lista.
Lbuscar
Tiene como precondición que el elemento X se encuentra en la lista.
Devuelve la posición del elemento X.
Lsiguiente
Devuelve la posición del siguiente elemento al de la posición POS.
Lprimero
Devuelve la posición del primer elemento de la lista.
Lsacar
Tiene como precondición que la posición es válida.
Quita el elemento que se encuentra en la posición POS y lo devuelve en X.
Te presentamos a continuación un ejemplo para que veas cómo es el funcionamiento de

una lista y cómo utilizar los operadores.
Ingresar números enteros por teclado. Luego, volver a ingresar números e informar
si ese número ya fue ingresado previamente y en qué orden.
SEUDOCÓDIGO
TIPOS
TDATO = ENTERO
TLISTA = LISTA de TDATO
VARIABLES
LISTA : TLISTA
DATO : TDATO
CONTINUAR : LOGICO
INICIO
Lcrear(LISTA)
Mientras (CONTINUAR Y NO Lllena(LISTA)) Hacer
ObtenerEntero(DATO)
Linsertarfinal (LISTA,DATO)
FinMientras
ObtenerEntero(DATO)
Si (Lestaenlista (LISTA,DATO)) entonces
Mostrar (“El número fue ingresado en orden:”,Lbuscar (LISTA,DATO))
Finsi
FinMientras
FIN
Para declarar una Lista debemos tener definido un nuevo Tipo de Dato.
Hacé clic y te explicamos qué declaramos en cada línea...

En el ejemplo definimos un nuevo tipo, en la sección TIPOS, que llamaremos TLISTA, que
será una Lista en donde los elementos son del Tipo TDATO. Del mismo modo, TDATO es
un Tipo de dato definido por el usuario, y está formado por un ENTERO.
Luego definimos la variable LISTA, donde se almacenará nuestra estructura LISTA y
DATO, que será el elemento de la lista que vamos a insertar y a buscar.
Ahora pasemos al algoritmo principal. Lo primero que se realiza es crear la lista, con el
operador lcrear. Luego se van pidiendo al usuario los números enteros y se los va
cargando uno a uno, al final de la lista con el operador linsertarfinal. De tal manera que
en la lista se mantiene el mismo orden en que fueron ingresados por el usuario.
Una vez que el usuario ingresó todos los datos. Se debe pedir nuevamente otro conjunto
de números enteros, y por cada uno de ellos se busca en la lista, con el
operador Lestaenlista. Si el elemento se encuentra, significa que ya fue ingresado, por lo
tanto, la ubicación que tenga en la lista será el orden que le dio el usuario al ingresarlo.
De esta manera se busca la posición utilizando el operador lbuscar.
Ingresar una cadena de caracteres de a un caracter por vez. Luego, ingresar un entero
positivo menor o igual a la cantidad de caracteres e informar el elemento que ocupa esa
posición. Por ejemplo si se lee: “Me gusta programar” y el número 4, se deberá mostrar
“g” (los espacios entre palabras cuentan como un caracter).
SEUDOCÓDIGO
TIPOS
TDATO = CARACTER
TLISTA = LISTA de TDATOVARIABLES
LISTA : TLISTA
DATO : TDATO
CONTINUAR : LOGICO
N, CANT : ENTEROINICIO
Lcrear(LISTA)
CANT <- 0
Mientras (CONTINUAR Y NO Lllena(LISTA)) Hacer
ObtenerCaracter(DATO)
Linsertarfinal (LISTA,DATO)
CANT <- CANT + 1
FinMientras Repetir
Mostrar ("Ingrese un entero positivo menor o igual a " ,CANT)
Ingresar (N)
Hasta que (N >= 0) Y (N <= CANT)
Para I <- 1 hasta N hacer
Lsacar (LISTA, Lprimero (LISTA), DATO)
Mostrar (DATO)
Finpara
FIN
En esta unidad, te presentamos otro tipo de ESTRUCTURAS DE DATOS,
las ESTRUCTURA DE DATOS ORDENADAS, ya que con ellas podrás almacenar y
recuperar los datos de acuerdo al orden en que fueron cargados.
Te presentamos las PILAS, donde cada elemento se accede desde un mismo extremo,
denominado CIMA. Luego te presentamos las COLAS, donde los elementos se cargan
desde un extremo (POSICIÓN FINAL) y se quitan desde el otro extremo (POSICIÓN
INICIAL). Finalmente te mostramos las LISTAS, donde los elementos se pueden agregar
y eliminar desde cualquier POSICIÓN.
A continuación, te proponemos que veas el siguiente video en el que te contamos lo que

vimos a lo largo de la unidad.
Introducción a Java
Introducción
Comenzamos con la unidad y lo primero que nos proponemos es explicarte la historia de

Java, el lenguaje que utilizaremos en nuestra materia para programar en objetos. Si bien no es
necesario conocer el origen de este lenguaje para poder programar, creemos que es
interesante contarte cómo surgió, ya que forma parte del proceso de cambio del paradigma de
programación estructurada al de programación en objetos.
Además, veremos las características principales de este lenguaje por las cuales lo hemos
elegido para explicarte cómo programar en objetos.
¡Comenzamos!
Historia de JAVA
En el año 1991 la empresa Sun Microsystem crea el proyecto The Green Project dedicado al
desarrollo de la tecnología Java, que se crearía como una herramienta de programación.
Este proyecto estaba en manos de un equipo de trece personas, dirigido por James Gosling. El
resultado de su trabajo fue un lenguaje de programación que no dependía de los dispositivos,
denominado "Oak".
La idea de este lenguaje era contribuir al futuro de los dispositivos digitales, por eso este
equipo desarrolló un controlador de mano destinado al uso de implementos domésticos, por
ejemplo, la televisión digital por cable. No dio resultado debido a que el sector de la
televisión digital por cable no estaba listo para el gran avance que la tecnología Java ofrecía.
Con la aparición en la década de los 90 de Internet y la utilización de los navegadores como

Netscape Navigator, alrededor del año 1996 se comenzó la incorporación de la tecnología
Java en estos navegadores.
Ya para comienzos del año 2000, la plataforma Java ha resultado muy atractiva para los
desarrolladores de software. Se la utiliza en los principales sectores de la industria de todo el
mundo y está presente en un gran número de dispositivos, computadores y redes de cualquier
tecnología de programación. Su versatilidad y eficiencia, la portabilidad de su plataforma y la
seguridad que aporta, la han convertido en la tecnología ideal para redes.
Continuemos...
< Anterior
Siguiente >
◄ Una pregunta para comenzar...
¿Por qué se diseñó JAVA?
A través de los años se han utilizado lenguajes de programación como C o Fortran para
diseñar sistemas complejos a partir de la programación estructurada, creando de esta
forma procedimientos complejos, de esto provienen los términos “código espagueti” o
“programas sábana”, que se refieren a programas que son muy extensos o cuya lógica es
muy difícil de seguir.
Como te contamos en la Unidad 1, a partir de ello se planteó un cambio en la

programación estructurada mediante la aparición de un nuevo
paradigma, denominado programación orientada a objetos.
Con la aparición de este paradigma, muchos de los lenguajes existentes decidieron

migrar a este estilo de programación. Un ejemplo de esto es el lenguaje C++, en el que
se intentó tomar los principios del lenguaje C y tratar de sacarle ciertas restricciones,
creando de esta manera un lenguaje híbrido y no netamente orientado a objetos.
Todos los compiladores de C++ son capaces de compilar código en ANSI C como así
también en C++, por lo que hace que el lenguaje sea débil, ya que en un estilo de
programación se puede incluir el otro.
Java fue concebido desde su nacimiento como un lenguaje orientado a objetos

puros y está basado en ciertas convenciones que posee el lenguaje C, como, por
ejemplo, declaración de variables, paso de parámetros y demás, pero sólo considera las
partes de C++ que no estaban ya en C.
A continuación, te contamos las principales características que Java no hereda de C++:
A continuación, te contamos las principales características que Java no hereda de C++:
(hacé clic sobre cada etapa para ver su descripción)
Punteros
Las direcciones de memoria son la característica más poderosa de C++. El inadecuado

uso de los punteros provoca la mayoría de los errores de colisión de memoria, errores
muy difíciles de detectar. En Java no existen punteros, lo que evita el acceso directo a la
memoria volátil.
Variables globales
Con ellas, cualquier función puede producir efectos laterales, e incluso se pueden
producir fallos catastróficos cuando algún otro método cambia el estado de la variable
global necesaria para la realización de otros procesos. En Java lo único global es el
nombre de las clases.
Sentencias goto
Son la forma más rápida de arreglar un programa rompiendo su estructura secuencia.

Java no tiene ninguna sentencia goto, pero posee las sentencias break y continue que
cubren los casos importantes de goto.
Asignación de memoria
Reservar memoria en C o C++ implicaba la utilización de sentencias como new o

mallocs, que creaban objetos en memoria, que el mismo programador era responsable
de eliminar de la memoria una vez que se los dejaba de utilizar y en la mayoría de los
casos se omitía hacerlo. Java, ante esta vicisitud, posee un Garbage Collector (recolector
de basura) que permite al programador desligarse de tener que eliminar los objetos de
memoria.
Conversión de tipos insegura
Los cambios de tipo (casting) son un mecanismo de C y C++ que permite cambiar el tipo
de un puntero. Java provee una comprobación de tipos de datos al momento de castear
un tipo en otro. El casting (a veces denominado casteo en el lenguaje informático) es la
conversión automática de tipos. Por ejemplo, si asignamos un número entero a una
variable de tipo real, se debe hacer un “casteo” del tipo entero al real.
Un poco de historia...
Como ya te hemos comentado al inicio de la unidad, Java fue diseñado en la década

del 90 por Sun Microsystems,como software para dispositivos electrónicos.
Curiosamente, este lenguaje fue diseñado antes de la explosión de la era de Internet,

para dispositivos electrónicos como calculadoras, microondas y la televisión interactiva
(electrodomésticos principalmente).
Logotipo de Sun Mycrosystems.
Originalmente Java se llamó Oak (roble), pero el nombre tuvo que cambiarse porque
ya se encontraba registrado por otra empresa.
Algunas de las principales razones que llevaron a crear Java son:
Más información....
Creciente necesidad de interfaces mucho más cómodas e intuitivas que los sistemas
que proliferaban hasta el momento.
Fiabilidad del código y facilidad de desarrollo. Se había observado que muchas de las
características que ofrecían otros lenguajes como C++ aumentaban el gran costo de
pruebas y depuración.
Enorme diversidad de controladores electrónicos. Los dispositivos electrónicos se

controlan mediante la utilización de microprocesadores de bajo precio y reducidas
prestaciones, que varían a menudo y que utilizan diversos conjuntos de instrucciones.
Java permite escribir un código común para todos los dispositivos.
Así, en vez de tratar únicamente de optimizar las técnicas de desarrollo, el Green Team
se planteó que tal vez los lenguajes existentes eran demasiado complicados para reducir
de forma apreciable la complejidad de desarrollo asociada a ese campo.
Axial surge como la primera propuesta, que fue idear un nuevo lenguaje de
programación lo más sencillo posible, con el objeto de que se pudiese adaptar con
facilidad a cualquier entorno de ejecución, otorgándole de esta manera el beneficio de la
portabilidad entre plataformas.
Tras la obtención de un gran conocimiento y estudio de distintos lenguajes, el Green

Team decidió adoptar las características esenciales de varios, pero eliminando todas
aquellas funciones que no eran absolutamente imprescindibles, para obtener así un
lenguaje de programación moderno y potente.
Entonces....
¿Cuál fue el primer proyecto en que se aplicó JAVA?
El primer proyecto en que se aplicó Java consistía en un sistema de control completo de

los aparatos electrónicos y el entorno de un hogar (DOMOTICA).
Para tal fin, se construyó un ordenador experimental denominado Star Seve (*7), que
poseía un sistema que presentaba una interfaz basada en la representación de la casa de
forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. En
el sistema aparecía la actual mascota de Java.
Otro proyecto en el que se aplicó Java fue Video On Demand (VOD), en el que se
empleaba como interfaz para la televisión interactiva, que se pensaba, iba a ser el principal
campo de aplicación de Java.
Ninguno de estos proyectos se convirtió nunca en un sistema comercial, y fueron
desarrollados enteramente en un Java primitivo.
Una vez que los expertos de Sun se dieron cuenta de que, a corto plazo, la televisión
interactiva no iba a ser un gran éxito, instaron a FirstPerson a desarrollar nuevas estrategias,
que produjeran beneficios. Entre ellas, se encontraba la aplicación de Java a Internet, la cual
no se consideró productiva en ese momento.
Aunque Java no llegó a caer en el olvido, lo cierto es que Bill Joy, cofundador de Sun y uno
de los desarrolladores principales del sistema operativo Unix de Berckley, reflotó a
Java, que había sido dejado de lado.
Joy tuvo la visión que Internet llegaría a ser el campo adecuado para disputar a Microsoft su
primacía en el terreno del software, y vio en el lenguaje creado por su empresa el instrumento
idóneo para llevar a cabo estos planes.
Para poder presentarlo en sociedad, se tuvo que modificar el nombre de este lenguaje de
programación y realizar una serie de modificaciones de diseño para poderlo adaptar al nuevo
propósito. Así, Java fue presentado en forma oficial en agosto de 1995, conjuntamente con el
explorador Netscape.
¿Qué razones habrán llevado a Joy a pensar en JAVA rentable?
• Java es un lenguaje orientado a objetos.
• Es un lenguaje sencillo, aunque sin duda potente.
• La ejecución del código Java es segura y fiable.
• Es totalmente multiplataforma.
Existen varias críticas a Java, debido que es lento en su velocidad de ejecución,

aproximadamente unas 20 veces más lento que un programa en lenguaje C ¿Cuál es el
problema? ¿Cuál sería la solución?
Veamos...
El problema fundamental de Java es que utiliza una representación intermedia denominada
byte codes para solventar los problemas de portabilidad. Estos códigos se deben transformar
en códigos máquina en cada máquina en que son utilizados, lo que enlentece
considerablemente su ejecución.
Una solución factible a este problema parece bastante obvia: fabricar computadoras capaces
de comprender directamente los códigos de byte. Éstas serían unas máquinas que utilizarían
Java como sistema operativo y que no requerirían, en principio, de disco duro, porque
obtendrían sus recursos de la red.
Hacé clic en el botón para ver más información.
En abril de 2009 Oracle adquirió Sun Microsystems, lo que generó temor en la comunidad
ante la posible mercantilización del lenguaje de programación orientado a objetos más
popular actualmente. Por ahora Oracle ha seguido manteniendo Java, estando las versiones
posteriores a la 6 bajo su control.
A continuación, te explicaremos las características de Java en forma más detallada.
Las características principales que nos ofrece Java y que lo distinguen de cualquier otro
lenguaje de programación, son:
(Hacé clic sobre cada concepto para ver su descripción)
Simple
Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos
usadas y más confusas de éstos. C++ es un lenguaje que adolece de falta de seguridad, pero C
y C++ son lenguajes muy difundidos, por ello Java se diseñó para ser parecido a C++ y así
facilitar un rápido y fácil aprendizaje.
Java elimina muchas de las características de otros lenguajes como C++, para mantener
reducidas las especificaciones del lenguaje y añadir características muy útiles como el
Garbage Collector. En JAVA no tendrás que preocuparte para liberar memoria, el Garbage
Collector se encarga de ello liberando bloques de memoria muy grandes, lo que reduce la
fragmentación de la memoria. Java reduce en un 50% los errores más comunes de
programación con lenguajes como C y C++, al eliminar muchas de sus características, entre
las que se destacan:
 Aritmética de punteros
 No existen referencias
 Registros (struct)
 Definición de tipos (typedef)
 Macros (#define)
 Necesidad de liberar memoria (free)
Orientado a objeto
Java implementa la tecnología básica de C++ con algunas mejoras y elimina algunas
características para mantener el objetivo de la simplicidad del lenguaje. Java trabaja con sus
datos como objetos y con interfaces a esos objetos. Soporta las tres características propias del
paradigma de la orientación a objetos que te estuvimos explicando en las unidades anteriores:
abstracción de datos, herencia y polimorfismo. Las plantillas de objetos son llamadas clases y
sus copias, instancias. Estas instancias, como en C++, necesitan ser construidas y destruidas
en espacios de memoria.
Distribuido
Java se ha construido con extensas capacidades de interconexión con el protocolo TCP/IP.
Existen rutinas para acceder e interactuar con protocolos como http y ftp. El protocolo http se
utiliza para conectarse a un recurso (por ejemplo un archivo o un servidor) dentro de una
misma red de datos; mientras que el protocolo ftp se utiliza para transmitir archivos de un
dispositivo a otro. Esto permite a los programadores acceder a la información a través de la
red con tanta facilidad como a los archivos locales.
Robusto
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en

tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar errores, lo antes
posible, en el ciclo de desarrollo. Java obliga a la declaración explícita de métodos,
reduciendo así las posibilidades de error. Maneja la memoria para eliminar las
preocupaciones por parte del programador de la liberación o corrupción de memoria.
También implementa los arrays o arreglos auténticos, en vez de listas enlazadas de punteros,
con comprobación de límites, para evitar la posibilidad de sobrescribir o corromper memoria.
Arquitectura neutral
Para establecer Java como parte integral de la red, el compilador Java compila su código a un
archivo objeto de formato independiente de la arquitectura de la máquina en que se ejecutará.
Cualquier máquina que tenga el run-time puede ejecutar ese código objeto, sin importar en
modo alguno la máquina en que ha sido generado. El código fuente Java se "compila" a un
código de bytes de alto nivel independiente de la máquina. Este bytecodes está diseñado para
ejecutarse en una máquina hipotética que es implementada por un sistema run-time, que sí es
dependiente de la máquina.
Seguro
La seguridad en Java tiene dos facetas. En el lenguaje, se eliminan características como los
punteros o el casting implícito que hacen los compiladores de C y C++, para prevenir el
acceso ilegal a la memoria.
El código de Java pasa muchos tests antes de ejecutarse en una máquina. El código se pasa a
través de un verificador de bytecodes que comprueba el formato de los fragmentos de código
y aplica un tester de teoremas para detectar fragmentos de código ilegal (código que falsea
punteros, viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un
objeto).
Si los byte-codes pasan la verificación sin generar ningún mensaje de error, entonces
sabemos que:
 El código no produce desbordamiento de operandos en la pila

 El tipo de los parámetros de todos los códigos de operación es conocido y correcto.
 No ha ocurrido ninguna conversión ilegal de datos, tal como convertir enteros en
punteros.
 El acceso a los campos de un objeto se sabe que es legal: public, private, protected.
 No hay ningún intento de violar las reglas de acceso y seguridad establecidas.
Portable
Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa
otros estándares de portabilidad para facilitar el desarrollo. Java construye sus interfaces de
usuario a través de un sistema abstracto de ventanas de forma que las ventanas puedan ser
implementadas en entornos Unix, Pc o Mac.
Integrado
El intérprete Java (run-time) puede ejecutar directamente el código objeto. Enlazar un

programa, normalmente, consume menos recursos que compilarlo, por lo que los
desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por la
ejecución. No obstante, el compilador actual del JDK es bastante lento. Por ahora, que
todavía no hay compiladores específicos de Java para las diversas plataformas, Java es más
lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no
ejecutado como sucede en cualquier programa tradicional.
Multithreaded
Primero, te contamos que los threads (hilos en español) son básicamente pequeños procesos o
piezas independientes de un gran proceso. Java, al ser multithreaded, permite muchas
actividades simultáneas en un programa. De esta manera, al estar los threads construidos en el
lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++.
El beneficio de ser miltithreaded consiste en un mejor rendimiento interactivo y mejor
comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las
capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los
entornos de flujo único de programa (single-threaded) tanto en facilidad de desarrollo como
en rendimiento
Dinámico
Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar
todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librerías
nuevas o actualizadas no paralizarán las aplicaciones actuales.
Para evitar que haya que estar trayendo los módulos de byte-codes o los objetos o nuevas
clases de la red cada vez que se necesiten, se implementan las opciones de persistencia, para
que no se eliminen cuando se limpie la caché de la máquina.
Ventajas y Desventajas del lenguaje JAVA

VENTAJAS
• No tenés que volver a escribir el código si querés ejecutar el programa en otra
máquina. Un solo código funciona para todos los browsers compatibles con Java o
donde se tenga una Máquina Virtual de Java (Mac's, PC's, Sun's, etc).
• Java es un lenguaje de programación orientado a objetos, y tiene todos los

beneficios que ofrece esta metodología de programación.
• Un browser compatible con Java deberá ejecutar cualquier programa hecho en Java,
esto ahorra a los usuarios tener que estar insertando "plug-ins" y demás programas que
a veces nos quitan tiempo y espacio en disco.
• Java es un lenguaje y por lo tanto puede hacer todo lo que suele brindar un lenguaje
de programación: Cálculos matemáticos, procesadores de palabras, bases de datos,
aplicaciones gráficas, animaciones, sonido, hojas de cálculo, etc.
• Si lo que interesa son las páginas Web, ya no tienen que ser estáticas, se le pueden
poner toda clase de elementos multimedia y permiten un alto nivel de interactividad, sin
tener que gastar en paquetes carísimos de multimedia.
DESVENTAJAS
• La velocidad. Los programas hechos en Java no tienden a ser muy rápidos,
supuestamente se está trabajando para mejorar esto. Como los programas de Java son
interpretados nunca alcanzan la velocidad de un verdadero ejecutable.
• Java es un lenguaje de programación. Esta es otra gran limitación, por más que
digan que es orientado a objetos y que es muy fácil de aprender, sigue siendo un
lenguaje y por lo tanto aprenderlo no es cosa fácil. Especialmente para los no
programadores.
características fundamentales para la ejecución de un programa en Java.
La máquina virtual de Java (en inglés Java Virtual Machine, JVM) es un programa
nativo, es decir, ejecutable en una plataforma específica, capaz de interpretar y ejecutar
instrucciones expresadas en un código binario especial (el Java bytecode), que es
generado por el compilador del lenguaje Java.
El código binario de Java no es un lenguaje de alto nivel, sino un verdadero código

máquina de bajo nivel, viable incluso como lenguaje de entrada para un
microprocesador físico.
La gran ventaja de la máquina virtual Java es aportar portabilidad al lenguaje de

manera que desde SUN se han creado diferentes máquinas virtuales Java para diferentes
arquitecturas y así un programa .class escrito en un Windows puede ser interpretado en
un entorno Linux. Tan solo es necesario disponer de dicha máquina virtual para estos
entornos.
Existen varias versiones, en orden cronológico, de la máquina virtual de Java. En general
la definición del Java bytecode no cambia significativamente entre versiones, y si lo
hacen, los desarrolladores del lenguaje procuran que exista compatibilidad hacia atrás
con los productos anteriores.
Ejecutando un programa en JAVA
Hasta este momento te has familiarizado con las principales características de Java.
Ahora podés comenzar a estudiar las etapas de la compilación y ejecución. Para ello, no
sólo vamos a darte las explicaciones necesarias, sino que te guiaremos para que
obtengas de la Web los programas necesarios y los instales en tu computadora.
Existe cierta serie de pasos que se deben realizar para poder ejecutar una aplicación en
Java.
Lo primero que hay que tener en cuenta es que los programas en Java no se ejecutan, ya
que el lenguaje es un lenguaje interpretado. Para ello se hace uso de la máquina virtual
de Java, que se encarga de interpretar los Bytecodes.
Etapas de compilación y ejecución de java
Paso 1
Escribir el código de Java, ya sea en un editor de texto común y corriente como el

notepad, o en un entorno integrado de programación (IDE) como es el Netbeans, entre
varios que existen en el mercado.
Paso 2
Grabar el archivo del código fuente con una extensión “.Java”, por ejemplo
“HolaMundo.Java”.
Paso 3
Compilar.
En esta etapa se verifican errores de sintaxis de lenguaje, como así también errores en pasaje
de parámetros y diferencia de tipos en las asignaciones, entre otras cosas.
Paso 4
Si la compilación fue exitosa (libre de errores), se genera otro archivo con el mismo
nombre, pero distinta extensión, en nuestro caso, se obtiene el archivo “HolaMundo.class”.
Para tener en cuenta....
En el archivo "HolaMundo.class" se encuentran los Bytecodes de nuestros programas,

que, cuando los pasemos por la máquina virtual, serán interpretados, produciendo de
esta manera la “ejecución” de nuestro programa.
¿Qué ocurre si se utiliza un IDE?

Todo resulta transparente para nosotros, debido a que el mismo entorno es quien se
encarga de invocar a las herramientas del JDK, ya sea tanto para la compilación como así
también para la ejecución.
¿Qué ocurre en caso de no poseer un entorno IDE?
En ese caso, tanto la compilación como la ejecución del programa se deben realizar
mediante la línea de comando.
A continuación, te detallamos en un gráfico todo lo expuesto anteriormente.
Instalación J2SDK
El JDK (o J2SE) es una distribución de herramientas de software para desarrollo de

aplicaciones en Java, que incluye bibliotecas, documentación, debugger y el ambiente de
software para tiempo de ejecución, más conocido como JRE (Java Runtime Environment).
Este último provee la máquina virtual de Java y las bibliotecas runtime requeridas para
ejecutar una aplicación Java.
Podés obtener el J2SE desde: < enlace >
Para instalar el J2SE, bastará con ejecutar el instalador que corresponda a la plataforma
de trabajo y seguir el happy path, esto es, presionar “Next” en cada ventana de diálogo
hasta que la instalación termine. Si sos un usuario de Linux, BSD, etc., deberás seguir los
pasos que van apareciendo en la consola.
Las herramientas que se incluyen dentro del JDK son:

• Compilador de Java (Javac): Compila programas escritos en el lenguaje de
programación Java convirtiéndolos en Bytecodes.
• Interprete de Java (Java): Ejecuta los bytecodes Java, es decir, ejecuta los programas
Java.
• Interprete de ejecución de Java (jre): Similar a Java, pero simplificado para los
usuarios que no necesiten herramientas de desarrollo para Java.
• Java AppletViewer (appletviewer): Herramienta para depurar y ejecutar applets.
• Depurador de Java (jdb): Herramienta para encontrar los fallos dentro de los
programas Java.
• Desensamblador de ficheros de clases (Javap): Herramienta que a partir de

bytecode, genera archivos de código en Java.
• Generador de documentación Java (Javadoc): Analiza las declaraciones y los

comentarios que están dentro de un conjunto de archivos fuentes Java y genera un
conjunto de páginas HTML describiendo las clases “public” y “protected”, las interfaces,
los métodos, los constructores y los campos. También genera una jerarquía de clases y
un índice con todos los miembros de la aplicación.
• Generador de cabeceras y cabos para C (Javah): Para utilizar métodos nativos en

lenguaje C desde Java.
• Herramienta de archivos de Java (jar): Combina varias clases Java y sus recursos
asociados en un único archivo.
• Herramienta de firmas digitales (Javakey): Gestiona entidades, incluyendo sus claves

y certificados.
• Convertidor Native-To-ASCII (native2ascii): Convierte un archivo con codificación

nativa a un fichero ascii en el que los caracteres no ascii aparecen con la notación de
Unicode \udddd.
• Generador de cabos para aplicaciones Java RMI (rmic).
• Registro de Objetos Remotos Java (rmiregistry): Servidor de directorio para objetos

de RMI.
• Comando para control de versiones (serialver): Proporciona el “serialVersionUID”

para una o más clases en un formato adecuado para copiarlo en clases en desarrollo.
• Utilidad de conversión AWT 1.1 (updateAWT): Actualiza los nombres que han
cambiado en los métodos de AWT 1.02 en una aplicación.
Bibliografía de referencia
Arnow, D., Weiss, G., & Sevilla Ruiz, D. (2000). Introducción a la programación con Java
(1st ed.). Madrid: Addison Wesley.
Deitel, H., & Deitel, P. (2004). Cómo programar en Java (5a. ed.) (1st ed.). Naucalpan de
Juárez: Pearson Educación.
Froufe Quintas, A. (2006). Java 2. México: Alfaomega.
Weiss, M., Marroquín, O., Segura, C., Verdejo, J., Frutos, D., & Llana, L. (2000). Estructuras
de datos en java (1st ed.). Madrid: Addison-Wesley.
Sintaxis de Java
Objetivos
 Usar la sintaxis básica del lenguaje Java.

 Aplicar las estructuras de control que posee el lenguaje Java.
Contenidos:
Variables, tipos de datos. Operadores unarios y binarios. Declaración e inicialización de

variables. Operadores matemáticos, lógicos y relacionales. Condicionales, alternativas y
ciclos iterativos. Definición de un pequeño programa en Java. Tipos de datos primitivos.
Casting. Definición de bytecodes. Virtual Machine de Java.
En esta unidad seguimos explicándote el lenguaje de programación que utilizaremos

para programar en objetos. Así, cada vez que comiences a aprender un nuevo lenguaje
lo primero que debés tener en claro es la sintaxis con la que se escriben los programas.
Es por eso que en esta unidad nos dedicaremos a comentarte las bases del lenguaje Java
y así aprenderás, mediante ejemplos, sus diversos componentes.
Definición de variables y tipos de datos

Recordemos lo que abordamos en la materia Técnicas de Programación.
Una variable es un identificador que se representa mediante una palabra. Toda variable ocupa
un lugar en memoria y este identificador contiene información. La información almacenada
en una variable puede ser de un solo tipo y almacenará datos del tipo con que se declaró esa
variable.
Veamos a continuación los distintos tipos de datos que pueden contener las variables....
Sintaxis de Java
Tipos de datos
En Java, los tipos de datos se pueden dividir en dos categorías:
 los primitivos, que son aquellos tipos de datos que provee el compilador y
 los abstractos, que son los creados por el programador.
A continuación te detallamos los tipos de datos primitivos que posee Java:
TIPO LONGITUD RANGO Inicializado

Lógico boolean 1 byte False
Textual char 2 bytes Comprende el código ASCII (0..255)
Integral byte 1 byte -128...127 0
short 2 bytes -32678...32677 0
int 4 bytes -2.147.483.648 y 2.147.483.647 0
long 8 bytes -9.223.372.036.854.775.808 y 0L
9.223.372.036.854.775.807
Punto float 4 bytes (6 y 7 cifras decimales equivalentes) 0.0F
flotante De -3.402823E38 a -1.401298E-45 y de 1.401298E-
TIPO LONGITUD RANGO Inicializado
45 a 3.402823E38
double 8 bytes (15 cifras decimales equivalentes). 0.0D
De -1.79769313486232E308 a
-4.94065645841247E-324 y de
4.94065645841247E-324 a 1.79769313486232E308
Habrás notado que todos los tipos de datos primitivos en Java se escriben en minúsculas. Esto
se debe a que el lenguaje es “Case sensitive” (sensible a mayúsculas), lo que significa que el
lenguaje hace diferencias entre mayúsculas y minúsculas, es decir, que no es lo mismo int
que Int o inT.
Todas las palabras reservadas del lenguaje Java se escriben en minúsculas.

Ahora te explicaremos con más detalle cada uno de los tipos de datos.
(Hacé clic en cada uno de los nombres)
Tipo de dato: Lógicos
Son variables que pueden almacenar dos tipos de valores true o false (verdadero o false). Por
lo general los utilizarás para almacenar resultados de evaluaciones lógicas.
Tipo de dato: Textuales
Son variables en las cuales se almacenan caracteres. Al asignar sus valores, deben encerrarse
entre apóstrofes (“’“). Los usarás para almacenar caracteres simples.
Tipo de dato: Integrales
Son variables en las cuales se almacenan valores numéricos de tipo entero con signo (+/-).
Dentro de ellas podrás almacenar valores en cualquiera de las siguientes formas:
 Decimal: los literales decimales aparecen como números ordinarios sin ninguna
notación especial.
 Hexadecimal: los hexadecimales (base 16) aparecen con un 0x ó 0X inicial, notación
similar a la utilizada en C y C++.
 Octal: los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en
decimal, como 0xC en hexadecimal, y como 014 en octal.
Definición de Variables
En Java, la definición de una variable es muy sencilla, primero se declara el tipo y luego
el nombre de la misma.
Veamos un ejemplo:
int numero;
Cada definición de variables se termina con un punto y coma (“;”). En caso de querer
definir más de una variable del mismo tipo se utiliza la coma (“,”) como separador.
Veamos un ejemplo:
int numero, exponente, base;
También se puede dar un valor inicial a las variables en el momento de definirlas:
Veamos un ejemplo:
int numero, exponente = 1;
1.Operador de asignación
Dentro de los operadores podemos encontrar cinco diferentes tipos, los cuales te
detallamos a continuación:
1. Operador de asignación
El operador de asignación es el signo igual “=”. Mediante este operador podrás asignar
valores a las variables.
Maximo = 100
Binarios
Se los denomina operadores matemáticos binarios porque el operador se aplica a dos
operandos.
Veamos la siguiente tabla...
Operador Uso Descripción

+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Calcula el resto de dividir op1 entre op2
El tipo de los datos devueltos por una operación aritmética depende del tipo de sus
operandos. Por ejemplo, si se suman dos enteros, se obtiene un entero como tipo
devuelto, con el valor de la suma de los dos enteros.
Estos operadores los debés utilizar con operandos del mismo tipo, o si no, realizar una
conversión de tipos de uno de los dos operandos al tipo del otro.
Cada uno de los operadores que te mostramos en la tabla anterior tiene a su vez una
forma abreviada a utilizar conjuntamente con el operador de asignación. A continuación
los describimos y te mostramos sus equivalentes.
Operador Uso Equivalente a...

+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
Sintaxis de Java
2. Operadores matemáticos: Unarios
Unarios
A estos operadores se los denomina así debido a que se aplican a una sola variable. Dentro
de los unarios contamos con dos operadores, el de incremento y el de decremento. Estos
operadores los podrás aplicar a las variables de los grupos Textuales, Integrales y Punto
Flotante.
Operador de incremento
Se lo llama de incremento porque aumenta en una unidad el valor que contiene en ese
momento la variable.
A este operador, a su vez, se lo puede diferenciar entre pos-incremento y pre-incremento.
 Pos Incremento
Para que comprendas mejor este operador te planteamos la siguiente declaración de

variables y código:
JAVA
int a, b = 2;
a = b++;
¿Cómo funciona este operador?
Primero se utiliza el valor de la variable y luego se incrementa en una unidad la variable b.
Este mismo ejemplo, sería equivalente a hacer:
JAVA
a = b;
b = b+1;
 Pre Incremento
Para que comprendas mejor este operador te planteamos la siguiente declaración de

variables y código:
JAVA
int a, b = 2;
a = ++b;
¿Cómo funciona este operador?

Primero se incrementa en una unidad la variable b y luego se utiliza el valor de la variable.
Este mismo ejemplo sería equivalente a hacer:
JAVA
b = b+1;
a = b;
Debés tener en cuenta que si este operador se aplica a una sola variable funciona de la misma
manera.
Veamos un ejemplo:
JAVA
int a;
a++;
++a;
En ambos casos se incrementa en una unidad al contenido de la variable a.
Operador de decremento
Se lo utiliza igual que al operador de incremento, pero la diferencia es que resta una unidad a
la variable que se le aplica. También existe el operador de pre-decremento y pos-decremento
(--)
Operadores relacionales
También llamados operadores de comparación. A estos operadores los utilizarás al

momento de evaluar condiciones lógicas.
En la siguiente tabla te detallamos los operadores que existen y sus significados:
Operador Uso Devuelve verdadero si...

> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
4. Operadores lógicos
Estos operadores sirven para realizar condiciones compuestas de tipo lógico. También se
los llama conectores lógicos.
Veamos cuáles son y sus correspondientes tablas de verdad asociadas.
JAVA
(A > 0) && (B > 0)
// Será true cuando A sea mayor a 0 y también B sea mayor a 0
(A > 0) || (B > 0)
// Será true cuando A sea mayor a 0 o cuando B sea mayor a 0
Operador Uso Significado

&& op1 && op2 op1 y op2
|| op1 || op2 op1 o op2
! !op1 op1 es falso
Veamos ahora las tablas de verdad:
P Q P && Q
VERDADERO VERDADERO VERDADERO
P Q P && Q
VERDADERO FALSO FALSO
FALSO VERDADERO FALSO
FALSE FALSO FALSO
P Q P || Q
VERDADERO VERDADERO VERDADERO
VERDADERO FALSO VERDADERO
FALSO VERDADERO VERDADERO
FALSO FALSO FALSO
P !P
VERDADERO FALSO
FALSO VERDADEO
Operadores de bits
Son los operadores que se utilizan a nivel BIT (comparaciones entre ceros y unos). Esos
operadores se utilizan para expresiones avanzadas, que no veremos en este curso.
Operador Uso Operación

>> op1 >> op2 Desplaza los bits de op1 a la derecha op2 veces
<< op1 << op2 Desplaza los bits de op1 a la izquierda op2 veces
>>> op1 >>> op2 Desplaza los bits de op1 a la derecha op2 veces (sin signo)
& op1 & op2 Conjunción BIT a BIT
| op1 | op2 Disyunción BIT a BIT
~ ! op Negación BIT
Orden de precedencia de los operadores

Cuando en una sentencia aparecen varios operadores, el compilador deberá elegir en
qué orden aplicarlos. A esto se le llamaprecedencia.
Los operadores con mayor precedencia son evaluados antes que los operadores con una
precedencia relativa menor. Sin embargo, podrás indicar explícitamente al compilador de
Java cómo querés que se evalúe la expresión, y para eso tendrás que usar paréntesis
balanceados ( ).
Te recomendamos que, para hacer que el código sea más fácil de leer y mantener, seas
explícito e indiques con paréntesis qué operadores deben ser evaluados primero..
En la siguiente tabla podrás ver la precedencia asignada a los operadores de Java. Los
operadores de la tabla están listados en orden de precedencia: cuanto más arriba
aparezca un operador, mayor es su precedencia. Los operadores en la misma línea tienen
la misma precedencia:
Tipo operadores Operadores de este tipo

Operadores posfijos [ ] . (parámetros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Multiplicación */%
Suma +-
Desplazamiento <<
Comparación < <= = instanceof
Igualdad == !=
AND a nivel de BIT &
OR a nivel de BIT ^
XOR a nivel de BIT |
AND lógico &&
OR lógico ||
Condicional ?:
Asignación = += -= *= /= %= &= ^= |= <<= = =
Ahora, te proponemos el siguiente código para que pienses cómo se resuelve:
x + y/100
Casting
Como te contamos en la Unidad 4, una de las características fundamentales de Java es el
Casting. Como recordarás, el cast es la conversión provisoria de un tipo de dato en otro,
en otras palabras es la asignación del valor de un tipo de una variable a otra variable de
un tipo de dato distinto.
Java realiza conversiones implícitas de menor a mayor rango. Eventualmente hay

pérdida de significancia al convertir enteros a punto flotante. Todas las conversiones de
mayor a menor rango deben ser explícitas por medio del operador de cast.
Para ello tendrás que anteponer entre paréntesis el tipo de dato al cual deseás castear.
Veamos un ejemplo...
Supongamos que queremos realizar la división entre dos variables de tipo entero y
queremos que su resultado se almacene en una variable de tipo float.
JAVA
int valor1, valor;
float resultado;
Valor1 = 5;
Valor2 = 2;
Resultado =valor1/valor;
¿Qué problema se nos presenta en este ejemplo?

El problema con el cual nos encontramos aquí es que la variable resultado no guarda
2.5, sino que guarda el valor 2, debido a que existe una regla que dice: “si la división es
entre valores enteros, el resultado es entero, pero si alguno de los dos valores o ambos
valores son reales el resultado de la división es real”. En este caso tanto valor1, como
valor2 son valores de tipo enteros. Al realizar en este caso la división da como resultado
2.5, pero al ser valores enteros el compilador trunca su parte decimal, por eso es que el
resultado de esta división da 2.
Así, en el caso supuesto que queramos que nos dé 2.5, debemos castear algunos de los
dos tipos de datos al momento de la división. Eso lo hacemos, como te contamos antes,
anteponiendo entre paréntesis el tipo de dato al cual se quiere convertir.
Por lo general el cast siempre se realiza hacia un tipo de dato mayor.
Veamos cómo queda entonces nuestro ejemplo:
JAVA
int valor1, valor2;
float resultado;
valor1 = 5;
valor2 = 2;
resultado = (float) valor1 / valor2;
Otra posibilidad, también es:
JAVA
int valor1, valor2;
float resultado;
valor1 = 5;
valor2 = 2;
resultado = valor1 / (float) valor2;
También se puede hacer de la siguiente manera:
JAVA
int valor1, valor2;
float resultado;
valor1 = 5;
valor2 = 2;
resultado = (float) (valor1/valor2);
A continuación, detallamos una tabla con los tipos de conversiones que se pueden
realizar
Tipo Origen Tipo Destino

byte double, float, long, int, char, short
short double, float, long, int
char double, float, long, int
int double, float, long
long double, float
float double
ACTIVIDAD 1
Te proponemos, como ejercicio, que realices un algoritmo que, dados dos números
imprima por pantalla su suma y su producto.
Te presentamos nuestra propuesta para que lo compares. (Hacé clic en el botón para ver la respuesta)
JAVA
public static void main (String []args)
{
int num1, num2;
num1 = 5;
num2 = num1 + 10;
num2 += 20;
System.out.println("Num1 = "+num1);
System.out.println("Num2 = "+num2);
System.out.println("La suma es = "+(num1+num2));
System.out.println("El producto es = "+(num1*num2));
}
Estructuras de control: Condicional

Ahora veamos cómo se escriben en Java las diferentes estructuras de control que te
presentamos en la materia Técnicas de Programación.
1. Condicional
Hasta el momento hemos visto fragmentos de código en los cuales cada instrucción se
ejecutaba una sola vez, en el orden en que aparecían. Sin embargo, como recordarás, con
frecuencia nos encontramos con situaciones en las se deben proporcionar ciertas alternativas,
que pueden o no ejecutarse dependiendo de los datos de entrada, reflejando el cumplimiento
o no de una determinada condición.
Ahora te presentamos un ejemplo para utilizar esta estructura.
Supongamos que queremos saber si un número es par o no.
¿Te acordás cómo hicimos el algoritmo?

A continuación te presentamos un código en el cual te mostramos el uso de una condición

para decidir si un número es par.
JAVA
public class Condicional
{
public static void main (String[] args) {
int valor = 2;
if ((valor % 2) == 0)
System.out.println ("El número es par");
System.out.println ("FIN DEL PROGRAMA");
}
}
A continuación, te haremos algunos comentarios acerca del código.
Más info...
En la línea 1 tenemos la definición de la clase donde se ejecutará el programa. En Java, los
programas se escriben dentro de clases, que contienen un programa principal, que es el que se
encuentra definido en la línea 2. Habrás notado que la clase tiene una llave de apertura y otra
de cierre, como así también el programa principal. Todo va encerrado entre llaves y a esto
denominaremos bloque.
En la línea 3 se encuentra la definición e inicialización de una variable entera.
En la línea 5 se encuentra el condicional, observá que la expresión lógica está compuesta de

un operador matemático (valor % 2) y de una comparación de tipo relacional ==.
En las líneas 6 y 7 encontramos una sentencia System.out,println (), que dentro de sus
paréntesis tiene un literales entre comillas dobles. Todo lo que se escriba ahí se visualizara
por pantalla, o sea que esta sentencia nos permite imprimir por pantalla resultados, leyendas,
cosas que queremos que el usuario vea.
El resultado del programa será que se visualice por pantalla:

PANTALLA
El número es par
FIN DEL PROGRAMA
Debido a que el resto de dividir 2 con 2 es igual a cero, por lo que entra en el bloque del
condicional, ejecuta la sentencia de impresión de pantalla y luego, al salir, ejecuta la segunda
sentencia.
¿Qué pasaría si el valor de la variable en lugar de ser 2 fuese 3?

Al resolver la expresión lógica nos daría un valor false ya que el resto de dividir 3 con
dos no es igual a cero, por ende no ingresa al bloque del if, y saltea la ejecución a la
línea 8, obteniendo como salida.
PANTALLA
FIN DEL PROGRAMA
De esta manera, la sintaxis de la instrucción condicional es la siguiente:
JAVA
if (expresión lógica)
{
Sentencias;
}
Alternativa
A partir del ejemplo anterior,
¿qué sucede si quiero saber si el número es par o impar, pero quiero que se muestre por
pantalla?
Una solución posible seria la siguiente:
JAVA
public class Condicional
{
int valor = 3;
if ((valor % 2) == 0) {
System.out.println ("El número es par");
}
if ((valor % 2) != 0) {
System.out.println ("El número es impar");
}
}
}
A simple vista, el código es el mismo, con la diferencia que agregamos un segundo

condicional (líneas 7,8 y 9) en el cual se evalúa si el resto de dividir el contenido de la
variable con dos es distinto de cero (negación del condicional original). ¿Cuál es el
problema de este código, entonces?, el problema radica en que el compilador realiza
dos preguntas, una para saber si es par y otra para saber si es impar. El anterior código
se podría mejorar utilizando en este caso una alternativa cuya sintaxis es así:
JAVA
if (expresión lógica)
{
Sentencias 1;
}
else
{
Sentencias 2;
}
Como habrás notado, la sintaxis es la misma que la de la condicional, con la diferencia

que se agrega un bloque else. En caso que la expresión lógica sea verdadera se ejecuta
el bloque del if, en caso que sea falsa se ejecuta el bloque del else.
Tené en cuenta que todos los bloques pueden contener una o más sentencias, pero no
puede haber bloques vacíos. En caso de existir bloques vacíos, verificá que la estructura
utilizada sea la correcta y verificá también la expresión lógica.
Ahora te proponemos que pienses cómo sería el ejemplo anterior con una alternativa. A
continuación te damos nuestra propuesta.
Hacé clic para ver la solución..

JAVA
public class Alternativa
{
int valor = 5;
if ((valor % 2) == 0){
System.out.println ("El numero es par");
}
else {
System.out.println ("El numero es impar");
}
}
}
También recordarás que pueden existir condicionales anidados. Son condicionales que
están unos dentro de otros.
Veamos un ejemplo:
JAVA
public class Anidados
{
int nota = 5;
if (nota >= 4){
if(nota <= 10)
System.out.println ("Aprobado");
else
System.out.println ("Nota mal ingresada");
}
else
System.out.println ("Desaprobado");
}
}
Tené en cuenta que, a veces, a ciertos condicionales anidados los podés evaluar en una
sola condición, si utilizás correctamente los conectores lógicos vistos con anterioridad.
Para ello, el compilador cuenta con una evaluación perezosa, que significa que si está
evaluando una conjunción y su primera componente es falsa, el compilador no sigue
evaluando la condición completa, ya que un valor falso en una conjunción produce un
valor falso.
Pero cuidado, porque no pasa lo mismo con la disyunción, ya que ambas componentes
deben ser falsas para que la disyunción sea falsa. Veamos un ejemplo de lo antes
mencionado.
JAVA
int valor = 50;
if ((valor <30) && ((valor % 2) == 0))
En este condicional ya la primera parte de la conjunción es falsa, por ende el compilador
no realiza la evaluación de ((valor % 2) == 0)), ya que determinó que la conjunción es
falsa.
Selección
Esta sentencia te permitirá ejecutar una de varias acciones en función del valor de una
expresión matemática o de un valor en particular. Es otra manera equivalente a la
utilización de alternativas anidadas cuando lo que se necesita es comparar la misma
expresión con diferentes valores.
Supongamos el siguiente ejemplo: quiero imprimir por pantalla el nombre del mes
ingresado.
JAVA
public class Seleccion
{
public static void main (String [] args) {
int mes = 2;
if (mes == 1) {
System.out.println ("ENERO");
}
else {
if (mes == 2) {
System.out.println ("FEBRERO");
}
else {
if (mes == 3) {
System.out.println ("MARZ0");
}
else {
if (mes == 4) {
System.out.println ("ABRIL");
}
}
}
}
}
}
Seguramente te habrás dado cuenta de que es una solución bastante compleja porque,
por cada condicional, se realiza una pregunta y eso toma tiempo. Es mejor expresar ese
código con una selección.
Su sintaxis es la siguiente.
JAVA
switch (expresión)
{
case constante 1: ..........
break;
case constante 2: ..........
break;
. . .
case constante n: ..........
break;
default: ...
}
Donde la expresión puede ser una variable de tipo byte, short, int o char, o también
puede ser el resultado de una evaluación lógica o una función matemática.
A continuación, recordemos cómo funcionan la selección....
Hacé clic para ver la solución...

Se evalúa la expresión. Dependiendo de su valor, seleccionará el case correspondiente,
ejecutará todas las sentencias que se encuentren en su bloque y al encontrar la sentencia
break saldrá de la selección.
En caso de no existir los breaks entre cada case, se ejecutarán todos los valores de las
constantes. En caso de no existir un valor que coincida con la expresión, se ejecutará el
default. La última sentencia no necesita llevar break precisamente por ser la última.
A continuación te presentamos cómo sería el código utilizado en esta sentencia.
JAVA
public class Seleccion
{
int mes = 2;
switch (mes) {
case 1: System.out.println ("ENERO");
break;
case 2: System.out.println ("FEBRERO");
break;
case 3: System.out.println ("MARZ0");
break;
case 4: System.out.println ("ABRIL");
break;
default: System.out.println ("OTRO MES");
}
}
}
Con esta sentencia, también podrás evaluar rangos.

Veamos un ejemplo:
JAVA
public class Rangos
{
int mes = 2;
switch (mes) {
case 1:
case 2:
case 3: System.out.println ("1er Trimestre");
break;
case 4:
case 5:
case 6: System.out.println ("2do Trimestre");
break;
case 7:
case 8:
case 9: System.out.println ("3er Trimestre");
break;
case 10:
case 11:
case 12: System.out.println ("4to Trimestre");
break;
default: System.out.println ("ERROR");

}
}
}

Funciones y Procedimientos con Parámetros

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Funciones y Procedimientos con Parámetros

Uploaded by

Copyright:

Available Formats

1) ¿Qué es el “tipo de dato”?

2) ¿Cuáles tipos de datos existen y que valores pueden contener?

1) Es la característica que tiene un valor que determina las operaciones que se

2) Los tipos de datos pueden se estándar o definidos por el Usuario.

Entero: puede contener un numero entero positivo o negativo incluyendo el

Real: Números reales. La cantidad de decimales que tenga un número dependerá

Carácter: Un solo símbolo (letra, digito, signo, etc.)

Cadena: Un conjunto de caracteres (palabra, frase, etc.)

Lógico: verdadero o falso

3) Las variables son datos que van cambiando en la ejecución de programas. Se

4) Variable: Su valor varia o se modifica durante la ejecución del algoritmo.

Constante: Su valor NO varía durante la ejecución del algoritmo.

5) El Primero es tipo Carácter, el segundo tipo Cadena y el tercero tipo Entero

“3”: Dato de tipo Cadena

‘3’: Dato de tipo Carácter

3: Dato de tipo Entero

Funcion que devuelva el valor absoluto de un numero entero.

Procedimientos con parámetros de entrada y salida

En la siguiente sección nos dedicaremos con más detalle a los parámetros y te

Procedimientos solo con parámetros de entrada

Procedimientos solo con parámetros de salida

Procedimientos sin parámetros

Veamos cómo se define un procedimiento de manera general.

Procedimiento que solicite al usuario un número entero por teclado y

Mediante los Parámetros podremos lograr la Abstracción y el Ocultamiento de la

A los parámetros que se encuentran en la definición de la rutina se los conoce

Parámetros por Valor

Identificamos a los parámetros que se sustituyen por valor anteponiendo la palabra

FUNCIÓN Promedio (VALOR NUM1:ENTERO, VALOR NUM2:ENTERO):REAL

También, podemos agrupar la definición en una forma equivalente:

FUNCIÓN Promedio (VALOR NUM1, NUM2:ENTERO):REAL

Los parámetros de Entrada se deben sustituir por Valor.

Tendremos dos identificadores apuntando al mismo espacio de memoria.

Identificamos a los parámetros que se sustituyen por referencia anteponiendo la palabra

PROCEDIMIENTO ObtenerEdad(REF EDAD: ENTERO)

Seguramente notarás que el valor del parámetro formal se modifica y, además,

Los parámetros de Salida se deben sustituir por Referencia.

Ejercicio parámetros el método de sustitución

Función ValorAbsoluto (valor NUM:ENTERO):ENTERO VAR ABSOLUTO : ENTERO

Variable es un espacio en memoria asociado a un nombre lógico.

A las Variables Globales se deben acceder solamente desde el programa principal,

A las Variables Locales se deben acceder solamente desde la rutina en que se

Función CantidadDivisores (valor NUM:ENTERO):ENTERO

También te comentamos cuáles son los beneficios de desarrollar módulos o

Te explicamos que los módulos en nuestros programas serán FUNCIONES o

En esta sexta unidad te presentamos ejemplos de Funciones y de Procedimientos

Estructuras lineales de datos

En esta unidad nos proponemos presentarte nuevas estructuras de datos para

Supongamos que queremos calcular el promedio de edades de los alumnos de un

Para definir un arreglo, como te contamos antes, necesitás conocer la cantidad de

La variable CE la utilizaremos para indicar la Cantidad de elementos lógica con la que

A un arreglo lo llamaremos Arreglo vacío cuando CE = 0 (un vector sin elementos)

Siempre se deben cumplir las siguientes condiciones:

CE >= 0 Y CE <= MAX

Podemos definir un arreglo de la siguiente manera:

• Conjunto finito: La cantidad de elementos de un arreglo es finita y se conoce en el

• Ocupan posiciones contiguas de memoria: Los elementos se almacenan en la

• Asociados a un mismo nombre: Un arreglo es una VARIABLE, por lo tanto tendrá un

El índice es la posición relativa que tiene cada elemento en el arreglo.

Recordemos que se tienen que cumplir las siguientes condiciones:

POS >= 1 Y POS <= CE

Veamos un ejemplo para entender el acceso a cada elemento.....