Introducción Al Paradigma Lógico, Funcional y Orientado A Objetos

GUA DE ESTUDIO
Paradigmas Programacin
Lenguajes Lgico, Funcional y O.O.

El propsito de esta Gua, no es reemplazar a la bibliografa del curso, su objeto es servir como
una introduccin y orientacin para el estudio, de los lenguajes abordados en cada paradigma.

Dpto. de Ingeniera en Sistemas de Informacin
UTN-FRM

PARADIGMAS DE PROGRAMACIN
Universidad Tecnolgica Nacional
Facultad Regional Mendoza

Prof. Oscar A. Len 2
N ND DI IC CE E
1. PROGRAMACIN LGICA ........................................................................................... 7
1.1. Lenguajes de programacin lgica............................................................................................7
1.2. Representacin de problemas ....................................................................................................8
1.2.1. Hechos....................................................................................................................................8
1.3. Metas u objetivos.........................................................................................................................9
1.3.1. Variables...............................................................................................................................10
1.4. Reglas..........................................................................................................................................12
1.4.1. Recurrencia...........................................................................................................................13
1.5. Interpretacin lgica.................................................................................................................16
1.6. Componentes de un programa.................................................................................................17
1.6.1. Dominios de valores.............................................................................................................17
1.6.2. Elementos predicativos ........................................................................................................18
1.7. Hechos y reglas. Preguntas y variables ...................................................................................18
1.8. Estructuras.................................................................................................................................21
1.9. Tratamiento de listas.................................................................................................................22
1.9.1. Predicado fail y variables annimas.....................................................................................24
1.9.2. Tratamiento de listas ............................................................................................................25
1.9.3. Estructuras y listas................................................................................................................27
1.10. Cadenas de caracteres.............................................................................................................28
1.11. Relacionadores lgicos y variables annimas .......................................................................29
1.12. Base de datos y bsqueda de objetivos..................................................................................32
1.13. Backtracking............................................................................................................................37
1.14. Operador de corte ...............................................................................................................41
1.15. Predicados predefinidos..........................................................................................................45
2. PROGRAMACIN FUNCIONAL .................................................................................. 48
2.1. Programacin funcional con Haskell ......................................................................................49
2.2. Principales caractersticas del lenguaje Haskell ....................................................................50
2.2.1. Funciones orden superior .....................................................................................................50
2.2.2. Sistemas de inferencia de tipos y polimorfismo...................................................................50
2.2.3. Pasaje de argumentos por nombre........................................................................................51

2.2.4. Valores como abstracciones.................................................................................................51
2.2.5. Sintaxis.................................................................................................................................52
2.3. Operadores y funciones ............................................................................................................54
2.3.1. Operadores lgicos...............................................................................................................54
2.4. Tipos de datos ............................................................................................................................54
2.4.1. Cadenas ................................................................................................................................55
2.5. Intrprete Haskell .....................................................................................................................55
2.6. Funciones....................................................................................................................................55
2.6.1. Definiciones locales .............................................................................................................56
2.6.2. Re-definicin de un operador...............................................................................................57
2.6.3. Definicin por patrones........................................................................................................57
2.6.4. Definicin por recursin o induccin...................................................................................58
2.6.5. Abstraciones lambda ............................................................................................................58
2.6.6. Funciones no estrictas ..........................................................................................................59
2.6.7. Iteraciones ............................................................................................................................59
2.7. Definicin de mdulos...............................................................................................................60
2.8. Tipos estructurados...................................................................................................................62
2.8.1. Listas ....................................................................................................................................62
2.8.2. Construccin de listas ..........................................................................................................62
2.8.3. Funciones sobre listas ..........................................................................................................63
2.8.4. Arreglos................................................................................................................................64
2.8.5. Estructuras de datos infinitas ...............................................................................................65
2.9. Tuplas .........................................................................................................................................66
2.10. Tipos definidos por el usuario................................................................................................66
2.10.1. Sinnimos de tipo...............................................................................................................66
2.10.2. Definicin de tipos compuestos .........................................................................................67
2.10.3. Definicin mediante campos con nombre..........................................................................68
2.11. rboles......................................................................................................................................68
3. PROGRAMACIN ORIENTADA A OBJETOS ............................................................ 70
3.1. El paradigma imperativo..........................................................................................................70
3.2. Construccin de programas O.O. ............................................................................................70
3.2.1. Nombres en las diferentes metodologas O.O. .....................................................................71
3.3. Tipos estructurados y abstractos .............................................................................................72
3.4. Lenguajes orientados a objetos ................................................................................................72
3.4.1. Lenguaje Java......................................................................................................................72
3.4.2. Paquetes................................................................................................................................73

3.4.3. Tipos primitivos y clases equivalentes.................................................................................74
3.4.4. Operadores ...........................................................................................................................74
3.4.5. Sintaxis del lenguaje ............................................................................................................75
3.5. Objetos........................................................................................................................................78
3.5.1. Descripcin de los objetos ...................................................................................................78
3.5.2. Definicin de clases .............................................................................................................79
3.5.3. Atributos...............................................................................................................................79
3.5.4. Mtodos................................................................................................................................80
3.5.5. Mensajes y mtodos .............................................................................................................80
3.6. Objetos de un programa...........................................................................................................80
3.7. Constructores y destructores de objetos .................................................................................81
3.8. Sobrecarga de mtodos .............................................................................................................82
3.9. Relaciones entre objetos ..........................................................................................................83
3.9.1. Notacin UML e implementacin en Java de relaciones.....................................................83
3.9.2. Herencia ...............................................................................................................................85
3.9.3. Agregacin ...........................................................................................................................90
3.9.4. Asociacin............................................................................................................................91
3.10. Excepciones..............................................................................................................................92
3.11. Threads.....................................................................................................................................95
3.11.1. Estados de un thread...........................................................................................................96
3.12. Asserts ......................................................................................................................................98
3.13. Programacin estructurada vs. O.O....................................................................................100
4. RESUMEN COMPARATIVO ENTRE JAVA Y SMALLTALK ..................................... 102


M Mo od de el lo os s d de e p pr ro og gr ra am ma ac ci i n n
A lo largo de la historia de los lenguajes de programacin, se han desarrollado diferentes
modelos de construccin y formas de ejecucin de programas, con el fin de poder abordar mejor
distintos dominios de problemas. Estos modelos de programacin se pueden clasificar segn
diversas caractersticas, y en muchos casos la implementacin de un lenguaje puede combinar ms
de uno de estos modelos.
Para los alcances de este curso adoptaremos la clasificacin propuesta por A. Tucker, R.
Noonam en Programming languages Principles and Paradigms. Los 3 principales modelos que
estudiaremos son el O.O., Lgico y Funcional, y se veremos uns introduccin a los modelos
Concurrente y Orientado a Eventos.
Paradigma Estructura de programas Forma de ejecucin Principales lenguajes
Imperativo Especificacin explcita de la
secuencia de ejecucin,
combinando enunciados de
asignacin y de control de la
secuencia de ejecucin.
Gobernada por la secuencia de
enunciados.
C, C++, Pascal, Fortran, Cobol,
Ada, etc.
Funcional La descripcin se hace a travs
de funciones y la composicin
de estas.
Gobernada por la secuencia de
llamadas entre funciones.
Lisp, Haskell, Scheme, ML, J,
etc.
Lgico La descripcin se hace a travs
de un conjunto de reglas
lgicas.

La secuencia de ejecucin no
est determinada, ya que es
gobernada por los resultados de
la evaluacin de los predicados.
Prolog
Orientado a
objetos
La descripcin se hace a travs
de clases, que incluyen
variables, funciones o
procedimientos, a partir de las
cuales se crean objetos.
La secuencia de ejecucin est
gobernada por el intercambio de
mensajes entre objetos.
SmallTalk, Eiffel (puros), Java,
Object Pascal (impuros), C++
(hbrido).
Orientado a
eventos
Consta de un lazo infinito que
constantemente escucha por
la ocurrencia de eventos en el
contexto del programa.
Gobernada por la generacin de
eventos producidos por
usuarios, dispositivos o
programas, en forma aleatoria.
Visual Basic, Java y por lo
general las implementaciones de
lenguajes de otros paradigmas
proveen medios para soportar
este modelo.
Concurrent
e
Conjunto de procesos que
comparten datos, los cuales
pueden estar organizados en
forma de bloques de
enunciados, funciones,
procedimientos o programas.
Se realiza en paralelo, en forma
asincrnica o sincrnica,
intercambiando datos entre los
procesos.
Fortran, C y lenguajes que
implementan el concepto de
Thread como Java.


G Ge en ne ea al lo og g a a d de e l le en ng gu ua aj je es s


P Pa ar ra ad di ig gm ma a L L g gi ic co o
Para el estudio de este paradigma es conveniente que repase los conceptos de lgica proposicional
y de clculo de predicados, estudiados en el curso de Matemtica Discreta.
1. PROGRAMACIN LGICA
En el modelo de programacin imperativa, diseamos los algoritmos que representan la
solucin de un problema, como un conjunto de sentencias en un orden determinado, definiendo
esquemas especiales para controlar exactamente la secuencia de ejecucin que se debe seguir. Esto
lo hacemos porque sabemos que debemos lograr que la computadora, a partir de un cierto estado
inicial que guarda en su memoria, debe, mediante una serie de transformaciones que denominamos
cambios de estado de la memoria, alcanzar un estado final que representa la solucin del problema.
Si recordamos cuando estudibamos Algoritmos y Estructuras de Datos, veremos que
muchas veces sabamos cmo solucionar un problema, pero se nos dificultaba poder expresarlo en
trminos algortmicos. Esto es as, porque se requiere invertir mucho tiempo pensando en el
procesamiento computacional, adems de las cuestiones vinculadas con el problema a resolver. En
otras palabras, debamos indicar cmo resolver cada una de las tareas, en lugar de slo indicar qu
es lo que queremos resolver.
El modelo de programacin lgica, nos permite efectuar la descripcin del proceso de
solucin de un problema en trminos mucho ms sencillos. Esto se debe, a que nos libera de tener
que expresar muchos de los detalles relacionados con el procesamiento computacional,
permitindonos de este modo dedicar nuestra mayor atencin slo al problema. As, podemos
expresar la solucin en trminos de una lgica cercana a la que usamos los seres humanos y no a la
que emplean las computadoras.
Por lo tanto, en el paradigma de programacin lgica, lo que hacemos es definir un conjunto
de relaciones lgicas sobre un cierto dominio, ya sean expresadas por extensin o por comprensin.
1.1. Lenguajes de programacin lgica
El exponente ms popular del paradigma de programacin lgica, es el lenguaje PROLOG.
El mismo fue desarrollado en Francia, en la dcada del 70 y gran parte de su difusin, se debi al
hecho de haber sido elegido como lenguaje de desarrollo para el proyecto japons de 5ta.
generacin, durante la dcada del 80. La palabra PROLOG est formada a partir de las tres primeras
letras de la frase PROgramming in LOGic.
El lenguaje no est diseado pensando en lograr una gran eficiencia de procesamiento desde
el punto de vista computacional, sino ms bien en aumentar la eficiencia en el proceso de
descripcin del problema a resolver, a partir de poder expresarlo en trminos lgicos. As,
PROLOG nos permite expresar la solucin de un problema casi en trminos de lgica pura, sin que
debamos tener en mente demasiadas consideraciones respecto a la estructura de control del flujo,
relacionado con el orden de ejecucin de las sentencias de un programa. Esto no quiere decir que
estas consideraciones desaparezcan por completo.
Este lenguaje es normalmente identificado como un lenguaje declarativo. Esto quiere decir
que el nfasis est puesto en tener que pensar las relaciones lgicas existentes entre las entidades

que participan de un problema, ms que en los pasos necesarios para resolverlo.
Cualquier problema que se encare en PROLOG, tambin puede ser solucionado con otro
lenguaje de programacin y a la inversa; sin embargo, en cada caso se tendrn ventajas y
desventajas. Por lo tanto es importante poder determinar cul es el ms adecuado en cada caso. Por
ejemplo, no va a ser muy fcil desarrollar ni tampoco eficiente en su procesamiento, un programa
complejo de procesamiento numrico, implementado en PROLOG. Lo mismo ocurre al revs si
pensamos en el desarrollo de un programa en C, que simule la estrategia de un juego como el
ajedrez.
Los lenguajes declarativos son adecuados para el procesamiento de simblico. La
manipulacin de smbolos es el ncleo de lo que se conoce como inteligencia artificial.
Debido a que nos libera de tener que atender a los detalles finos de un programa, nos
permite representar la solucin de un problema con un alto nivel de abstraccin, dedicando nuestro
principal esfuerzo a pensar en las caractersticas del problema. Por esto, es un lenguaje ptimo para
construir rpidamente el prototipo de un sistema, y probar una variedad de enfoques diferentes para
resolver un problema. Luego, se puede re-escribir el programa en algn lenguaje que sea eficiente
desde el punto de vista del procesamiento.
Algunas de las reas de aplicacin del lenguaje son:
1. Sistemas expertos
2. Bases de datos deductivas
3. Interfaces de lenguaje natural
4. Sistemas que requieran alguna forma de razonamiento
1.2. Representacin de problemas
En programacin lgica para representar el modelo de un problema, debemos olvidarnos de
cmo es el detalle de la secuencia de sentencias necesarias para plantear la solucin del problema y
slo debemos analizar, qu relaciones lgicas existen entre los elementos que participan del
problema.
1.2.1. Hechos
Analicemos un problema que nos dio mucho trabajo cuando estudiamos su representacin
en trminos algortmicos. Se trata de las relaciones de parentesco entre personas, en el cual, a partir
de representar por medio de una matriz de adyacencia de grafos el conjunto de relaciones de padres
a hijos, debamos desarrollar los algoritmos para encontrar los primos de alguien, o los hermanos,
tos, etc.
Comencemos por identificar los elementos que participan del problema que nos hemos
planteado. Estos, son los nombres de las personas entre las que existen parentescos, por lo tanto
tomemos el siguiente conjunto de nombres definido por extensin:
nombres = {juan, raul, maria, monica, jorge, pedro, luis, ana}
Ahora debemos indicar cul es el vnculo que existe entre los elementos de ese conjunto.

Para esto definimos una relacin a la llamaremos padre y diremos que relaciona pares de
elementos, de modo tal que expresa que el primer elemento es el padre del segundo. En otras
palabras se trata de una relacin binaria, entre los elementos de un conjunto que indica que un X es
padre de un Y. Luego podemos indicar el conjunto de estas relaciones:
padre(juan, maria).
padre(juan, jorge).
padre(jorge, pedro).
padre(raul, monica).
padre(pedro, luis).
padre(pedro, ana).
Obsrvese que lo que hemos hecho, es tomar algunos de los pares ordenados del producto
cartesiano de los elementos del conjunto de nombres.
Para mantener la coherencia en la representacin del problema, debemos respetar el orden
de los pares, ya que la interpretacin que se har de los mismos es: padre, hijo. Esta ltima
interpretacin de la semntica de representacin de las relaciones queda a cargo del usuario, ya que
en el programa slo se expresan los elementos sintcticos del problema.
Los hechos son afirmaciones categricas, que no necesitan ser demostradas. En un programa,
vienen a ser los axiomas a partir de los cuales desarrollamos al mismo.
Sintaxis:
<hecho> ::= <nombre> ( < trmino> { , <trmino> } ) .
<nombre> ::= a..z { a..z | 0..9 | _ }
<trmino> ::= <variable> | <constante>
<variable> ::= A..Z { A..Z | a..z | 0..9 | _ }
<constante> ::= <entero> | <real> | <caracter> | <cadena> | <lgico>| <tomo>
donde los trminos, son elementos relacionados entre s, por eso a un hecho a veces tambin
se le llama relacin.
1.3. Metas u objetivos
Hasta ahora hemos escrito el conjunto de relaciones que representan nuestro problema,
ahora veamos como hacemos para obtener respuestas a nuestras preguntas, haciendo que se ejecute
nuestro programa.
Dependiendo de la versin de PROLOG que tengamos, es como el sistema se comunica con
nosotros. En general lo hace con el siguiente smbolo: ?- (en algunos sistemas coloca la palabra
goal: ).
Este es el medio por el cual nos indica que est en espera de que le pidamos que haga algo.

Podemos pedirle que nos conteste si una afirmacin que hacemos es cierta o no, por ejemplo
supongamos que en la base de datos existe el hecho padre(pedro, ana). Entonces podemos
preguntar si es verdad que el padre de ana es pedro.
?- padre(pedro, ana).
El sistema nos contestar si (yes). Si no existiera el hecho en su memoria, nos indicara un
error. Tambin puede ser que nos conteste no, si tiene almacenado el hecho, pero la afirmacin que
hacemos es falsa, por ejemplo:
?- padre(mauricio, ana).
responder no
1.3.1. Variables
Ahora podemos necesitar preguntar al sistema, no para que confirme o niegue algo, sino
para que por ejemplo nos responda respecto de cual es el nombre del padre de alguien. En ese caso
la pregunta sera as:
?- padre(V, ana).
A lo que se responder:
V = pedro
Para dar esta respuesta, el procesador del lenguaje debi descubrir que existe una relacin de
la forma padre(nombre, nombre), para la cual se cumple que el segundo argumento es ana,
regresando entonces como respuesta el valor del primer argumento en la variable V.
A partir de las definiciones hechas, podemos operar con las mismas, para obtener ms
resultados. Algunas de las operaciones que podemos efectuar en programacin lgica son:
1. Restricciones sobre los elementos de un conjunto.
2. Proyecciones sobre los dominios.
3. Preguntas de pertenencia.
La forma de expresar estas operaciones se realiza mediante el uso de variables, las cuales
pueden estar ubicadas en algunos de los argumentos de la relacin.
De este modo, si queremos saber quienes son los hijos de Juan, podemos obtener la
respuesta a partir de expresar una relacin, obtenida de la inicial, por restringirla para aquellas
tuplas que tienen a Juan en el primer argumento, y aplicando la proyeccin al segundo, lo cual
queda expresado en programacin lgica del siguiente modo:
?- padre(juan, Y).
En este caso la conclusin ser la respuesta que nos da el procesador del lenguaje, ante la
formulacin de una proposicin formada por una nica relacin, que indica que hay que efectuar
una proyeccin sobre el segundo argumento. El resultado ser:
Y = maria

Y = jorge
Para esto el sistema debi encontrar que estn definidos dos hechos de la forma
padre(nombre, nombre), en los cuales el primer argumento es juan y devolver en devolver en cada
caso, en la variable Y el valor correspondiente.
Por ejemplo si quisiramos indagar acerca de quien es le padre de luis, podemos expresar
esta pregunta en los siguientes trminos lgicos:
?- padre(X, luis).
la respuesta es:
X = pedro
Una caracterstica muy importante de la programacin lgica, es que una vez expresadas las
relaciones entre los elementos de un conjunto, podemos indagar por un valor para cualquiera de
ellos.
La aparicin de una constante como argumento, indica una restriccin. En cambio la presencia de
una variable, expresa una proyeccin.
Entonces, una pregunta expresada del siguiente modo:
?- padre(pedro, luis).
Corresponde a una restriccin que da como resultado una sola tupla, en este caso, el
procesador del lenguaje, dar como resultado verdadero o falso, segn sea que existe o no la tupla
entre las tuplas definidas por el producto cartesiano.
En otro caso la pregunta:
?- padre(X, Y).
La respuesta es la proyeccin de todas la tuplas definidas por el producto cartesiano:
padre(juan, maria)
padre(juan, jorge)
padre(jorge, pedro)
padre(raul, monica)
padre(pedro, luis)
padre(pedro, ana)
La interpretacin lgica de una proposicin, se satisface s y slo s, el resultado de su evaluacin
es verdadero.

1.4. Reglas
Ahora, si a partir de las relaciones de padre anteriores, necesitramos expresar las de ser
abuelo de alguien, deberamos escribir lo siguiente:
abuelo(juan, pedro).
abuelo(jorge, luis).
abuelo(jorge, ana).
Sin embargo, estas relaciones pueden expresarse de una forma ms general diciendo que:
alguien es abuelo de una persona, si es el padre, del padre de dicha persona.
Entonces a partir de los hechos antes enunciados vamos a definir lo que se llaman reglas, las
cuales nos permiten deducir ciertos hechos a partir de otros. Ahora la relacin de abuelo, podemos
indicarla as:
abuelo(X, Y) :- padre(X, Z), padre(Z, Y).
donde hemos expresado con variables, que si un X es padre de un Z, y ese Z es padre de un
Y, entonces implica (o se puede inferir) que X es abuelo de Y. A este esquema de construccin
tambin suele denominrselo como, regla de inferencia.
Entonces si preguntamos:
?- abuelo(juan, pedro).
nos contestar:
yes
si indagamos por:
?- abuelo( X, ana).
la respuesta es:
X = jorge
Para llegar a esta conclusin el sistema debi encontrar un hecho cuya estructura coincidiera
con la de la pregunta. Luego, darse cuenta de que el hecho est condicionado a que se cumplan
determinados requisitos, que son: encontrar un valor de X que sea padre de un Z, tal que, a su vez Z
sea padre de ana.
Tambin podemos escribir una regla para determinar el hermano de alguien:
hermano(X, Y) :- padre(Z, X), padre(Z, Y).
la cual expresa que un X es hermano de un Y, s se cumple que existe un Z que es padre de
X y adems ese Z es padre de Y.
Otro ejemplo sera la relacin de nieto:

nieto(X, Y) :- padre(Z, Y), padre(X, Z).
que dice que un Y es nieto de un X, s existe un Z que es padre de Y y X es padre de Z.
Como podemos ver, una regla se satisface s y slo s, se satisface el conjunto de proposiciones que
la implican o sea que la evaluacin de cada una es verdadera.
Una regla es una relacin (o predicado) que se infiere a partir de un conjunto de
proposiciones, o sea que se trata de una conclusin. El esquema de una regla es:
CONCLUSION <= PROPOSICIONES
donde PROPOSICIONES, es un conjunto de una o ms proposiciones lgicas (de las cuales
se pueden afirmar valores de verdad) y CONCLUSION, representa aquella relacin que es
implicada por las proposiciones (o sea que puede ser inferida a partir de estas).
Sintaxis:
<regla> ::= <relacin> :- <proposiciones> .
<relacin> ::= <nombre> ( < trmino> { , <trmino> } )
<proposiciones> ::= <proposicin> { , | ; <proposicin>}
<proposicin> ::= <condicin> | <hecho> | <relacin>
donde el signo :- reemplaza al smbolo de implicacin =>, la , indica conjuncin lgica y
el ; expresa disyuncin.
Si observamos las definiciones sintcticas anteriores, podemos notar que una regla se infiere
a partir de proposiciones de las cuales tiene sentido afirmar que son verdaderas o falsas, y que estas,
pueden formarse a partir de una condicin lgica, un hecho o una relacin. En este ltimo caso,
podra ser la misma de la que forma parte, por lo tanto la definicin de una regla puede ser
recursiva.
? Definir relaciones padre-hijo, y luego las reglas necesarias para evaluar las relaciones de: to,
sobrino, primo, ancestro.
1.4.1. Recurrencia
Veamos cmo resolver el problema de calcular el factorial de un nmero. Podramos
intentar hacerlo as:
factorial(1, 0).
factorial(1, 1).
factorial(2, 2).
factorial(6, 3).
factorial(24, 4).
factorial(120, 5).
...

Evidentemente esta forma no es muy prctica, ya que necesitaramos definir por extensin
todos los hechos, a razn de uno por nmero para el cual deseamos calcular el valor del factorial.
Entonces podemos tratar de hacerlo, empleando a partir de la definicin que hemos
estudiado en los cursos de matemticas. La misma, en los trminos de la simbologa de lgica
proposicional, podemos describirla as:
x / x = 0 : Factorial = 1 para todo x, tal que x es igual a cero, se cumple
que el factorial es igual uno
x / x > 0 : Factorial = x . Factorial(x 1) para todo x, tal que x es mayor a cero, se cumple
que el factorial es igual a x multiplicado por el
factorial de x 1
Luego en trminos de relaciones podemos escribir lo siguiente:
Sea n = {conjunto de nmeros naturales}, la relacin que expresa el producto cartesiano de
las tuplas n
x
n, puede escribirse como factorial (n, n), lo cual interpretaremos que representa el
conjunto de pares ordenados de nmeros naturales, donde el primero es el valor de factorial
correspondiente al segundo argumento.
Entonces podemos describir un pseudocdigo como el siguiente:
factorial(1, 0) Es un axioma que expresa que el factorial de 0 es 1
factorial(F, X) X > 0 Y
factorial(Z, X 1) Y
F = X . Z
a) Expresa que si X es mayor que 0, y existe un Z
que es el factorial de X 1, y F es igual al producto
de X por Z, entonces podemos concluir que F es el
factorial de X
b) La regla leda al revs, expresa que F es el
factorial de X, si se cumple que X es mayor a 0, y
existe un Z que es el factorial de X1, y F es igual
al producto de X por Z
En la definicin anterior, tenemos una regla (implicacin lgica) de tipo recurrente, ya que
se define en trminos de s misma.
Veamos ahora como es la sintaxis en PROLOG, del programa y luego analicemos el
proceso de ejecucin del mismo.
factorial(1, 0).
factorial(F, X) :- X > 0, Y is X 1, factorial(Z, Y), F = X Z .
Una meta podra ser:
?- factorial(N, 3).
y la respuesta:
N = 6
Nota: Se us en la regla el operador is dado que algunas versiones de PROLOG no aceptan

colocar una expresin como argumento de un predicado.
Al ejecutarlo, el sistema busca aquellos hechos o reglas que coincidan con la estructura de la
proposicin dada es decir: factorial(valor, numero). Por lo tanto se intenta verificar las mismas, ya
sea por inferirlas a partir de las proposiciones lgicas, ubicadas a la derecha de la implicacin :-, o
verificando con los hechos. Las clusulas son evaluadas en el orden en que aparecen en el
programa. Analicemos el siguiente esquema:
REGLA A VERIFICAR RESULTADO PROPOSICIONES CON VALORES RESULTADO
1. Se intenta verificar las reglas para: factorial(N, 3)
factorial(1, 0) falla
factorial(F, X) X >0 3 >0 ok
Y =X 1 2 =3 1 ok
factorial(Z, 2) recurrencia
2. Se intenta verificar las reglas para: factorial(Z, 2)
Y =X 1 1 =2 1 ok
factorial(1, 0) falla F = 1 * 1
Y =X 1 0 =1 1 ok
factorial(1, 0) ok y regresa a 3
5. Se intenta terminar de verificar las reglas para: factorial(Z, 1)
factorial(1, 0) falla F = 1 * 1
Y =X 1 0 =1 1 ok
factorial(Z, 0) ok
F =Z * X 1 =1 * 1 ok y regresa a 2
Por lo tanto la evaluacin de la etapa 3, da un resultado verdadero, entonces para la
proposicin: factorial(F, X) con X = 1, regresa el valor N = 1.
6. Se intenta terminar de verificar las reglas para: factorial(Z, 2)
Y =X 1 1 =2 1 ok

factorial(Z, 1) ok
F =Z * X 2 =1 * 2 ok y regresa a 1
proposicin: factorial(F, X) con X = 2, regresa el valor N = 2.
7. Se intenta terminar de verificar las reglas para: factorial(N, 3)
Y =X 1 2 =3 1 ok
factorial(Z, 2) ok
F =Z * X 6 =2 * 3 ok y regresa
proposicin: factorial(N, 3) regresa el valor N = 6.
Obsrve que todas las proposiciones deben ser satisfechas para que una regla sea vlida.
?Definir los hechos y reglas para expresar la sucesin de Fibonacci.
1.5. Interpretacin lgica
Como se puede ver, en un lenguaje lgico, expresar la solucin del problema de los
parentescos es bastante simple, ya que slo hay que indicar a partir de que proposiciones lgicas, se
pueden concluir las relaciones que nos interesan.
En ningn caso se ha indicado como hay que procesar los datos para obtener el resultado, ya
que esto sera la expresin del algoritmo de solucin, y en este paradigma de programacin lo que
se debe indicar es qu es lo que se quiere obtener (el objetivo o meta buscados), y no como hacerlo.
Esto ltimo es as, al grado de que a menudo casi podemos traducir expresiones de nuestro idioma
habitual a PROLOG con poco esfuerzo. Por ejemplo:
PROLOG LENGUAJE NORMAL
esta_en(mendoza, argentina). mendoza est en argentina
nacio_en(ana, argentina). ana naci en argentina
es(Persona, argentina) :- una persona es argentina si
nacio_en( Persona, Ciudad ), esa persona naci en una ciudad y
esta_en( Ciudad, argentina). esa ciudad est en argentina
Por supuesto que en todo esto no hay nada mgico. Lo que ocurre es que todo el proceso de
deduccin, es realizado por lo que se conoce como motor de inferencia del lenguaje, en el cual ya
estn programados los algoritmos para solucionar los problemas relacionados con la bsqueda de
objetivos.
Para poder trabajar, PROLOG cuenta con una memoria que llamaremos base de datos o
base de conocimientos. En la misma almacena los hechos (axiomas) y reglas de inferencia, que le

suministramos al sistema y a partir de las cuales es capaz de llegar a determinadas conclusiones
lgicas.
La ejecucin de los programas es llevada a cabo por un intrprete, a partir de un cdigo pre-
compilado. Bsicamente lo que hace el procesador del lenguaje, es intentar satisfacer el conjunto de
reglas que le permite contestar a nuestra pregunta. Para esto determina los valores de verdad de las
proposiciones lgicas que figuran en las reglas, a fin de encontrar un valor de solucin para la
misma. Esta tarea es llevada a cabo por el motor de inferencia del lenguaje.
Los lenguajes del paradigma de programacin lgica, se basan en lgica de predicados de primer
orden.
1.6. Componentes de un programa
Como vimos, la construccin de programas en el paradigma lgico, se fundamenta en la
definicin de dominios de valores y de conjuntos, de hechos y de reglas.
Las respuestas se obtienen por un proceso de evaluacin (inferencia lgica), el cual es
llevado a cabo por el procesador del lenguaje. En resumen, el procesamiento de un programa, se
basa en la demostracin o prueba de una o ms reglas, a partir de un conjunto de axiomas.
1.6.1. Dominios de valores
Como ya vimos son representados por medio de constantes y variables. Ejemplos de esto, en
los casos anteriores son: ana, juan o X, Y, V.
PROLOG puede servirnos como medio para indagar si un hecho es cierto o no. Para que esto
pueda realizarse el sistema debe ser capaz de encontrar el hecho en su memoria. Desde luego que si
nosotros no hemos incorporado este hecho en la base de datos, no lo encontrar.
Los hechos pueden estar formados por uno o ms trminos. Estos ltimos son elementos
bsicos de la sintaxis del lenguaje. Un trmino puede ser un tomo, un entero, o un variable. El
hecho noche es un tomo, que est formado por un conjunto de caracteres, que es tratado como una
unidad indivisible de informacin.
Por ejemplo, son tratados como tomos:
noche es_de_dia A103
Tambin lo son, los siguientes smbolos:
$ % ^ & * - + = : . <>~ # @ ? / |
No son tratados como tomos:
es-de-dia 3AC 23.56 986
Como se indic en la definicin sintctica de variable, los nombres de estas deben comenzar
con una letra mayscula. Podemos distinguir tres clases de variables:
1. Libres: aquellas que no tienen valor asignado o sea que no referencian dato alguno.
2. Instanciadas: las que se refieren a un valor especfico.
3. Annimas: no tienen nombre, ni valor definido y se usan, cuando hay que indicar en una

relacin, que con ella se instanciar un objeto que no interesa referirlo, o que no se
puede referenciar en forma explcita. Se vern en detalle ms adelante.
1.6.2. Elementos predicativos
Se materializan en relaciones como: padre(juan, adriana)., la cual no es otra cosa que un
hecho, que afirma que juan es el padre de adriana.
Una clusula como:
abuelo(juan, pedro) :- padre(juan, luis), padre(luis, pedro).
representa la afirmacin (condicionada) que dice que: si es cierto que juan es padre de luis,
y que luis es padre de pedro, entonces se puede concluir que juan es abuelo de pedro.
Las proposiciones lgicas que aparecen a la derecha del smbolo de implicacin, pueden
estar constituidas por hechos, o condiciones que deben ser evaluadas.
Si la ltima regla la escribimos empleando variables:
abuelo(X, Y) :- padre(X, Z) Y padre(Z, Y).
la misma representa la afirmacin que para todo valor posible de X e Y, si existe un Z, tal
que X es padre de Z, y Z es padre de Y, entonces X es abuelo de Y.
Por ltimo la expresin:
? abuelo(juan, pedro).
indica que se desea determinar si la proposicin lgica que aparece en la misma, es cierta o
falsa, en el contexto del programa.
1.7. Hechos y reglas. Preguntas y variables
Las estructura de los predicado o clusulas est muy ligada con las preguntas que podemos
hacerle a PROLOG. Supongamos el siguiente hecho:
autor( Juan Carlos, Algebra, EUDEBA, 36.56 ).
donde cada argumento de este, es un trmino, los tres primeros son cadenas de caracteres y
el ltimo es de tipo real.
A continuacin se muestra la estructura de este hecho.


Luego, si definimos algunos hechos ms en la base de datos del sistema:
autor( Daniel Alberto ).
autor( Ana Maria, Filosofa ).
Aqu todos los hechos autor son predicados (o clusulas). El primero es un predicado autor
con cuatro argumentos, el segundo tiene un argumento y el tercero dos.
El nmero de argumentos de un predicado es lo que se denomina aridad.
Un predicado sin argumentos, tiene aridad cero. Las aridades de las clusulas anteriores son
4, 1, 2 respectivamente. En algunos libros esto puede estar representado como:
autor/4
autor/1
autor/2
Cuando hacemos una pregunta, PROLOG utiliza mecanismos conocidos como pattern
matching, para tratar de encontrar un predicado, cuyo esquema coincida con el de la pregunta que
efectuamos en la base de datos. Si este existe el sistema responde: yes en otro caso no.
Para que ocurra una coincidencia, deben ser iguales la pregunta y el hecho existente en la
base de datos, incluyendo la aridad. As, asumiendo que el siguiente hecho ya existe:
autor( Juan Carlos, Algebra, EUDEBA, 36.56).
si preguntamos:
?- autor( Juan Carlos, Algebra ).
la respuesta es no
Debido a que no coinciden la estructura de la pregunta con la del predicado. Ahora veamos
como hacer preguntas utilizando variables. Supongamos que hacemos la pregunta:
?- autor( Autor, Filosofa ).
PROLOG va a reconocer que Autor es una variable, debido a que esta comienza con
mayscula y no est encerrada entre comillas (en ese caso sera una cadena). Entonces cuando una
variable aparece en una pregunta, el sistema trata de encontrar un valor para la misma y para esto,
busca en la base de datos algn hecho que coincida con la estructura de la pregunta. La respuesta en
este caso ser:
Autor = Ana Mara

Observemos que slo existe un hecho que responde a la estructura de la pregunta y un solo
libro de filosofa. Cuando una variable coincide con un valor constante como en el caso previo, se
dice que la variable, en este caso, Autor ha instanciado a la constante Ana Mara.
Si tuviramos varios hechos con una estructura similar como:
autor( Daniel Martin, Filosofa ).
autor( Pablo Perez, Filosofa ).
autor( Maria Lopez, Filosofa ).
La pregunta:
?- autor( Autor, Filosofa ).
tendra como respuestas:
Autor = Daniel Martin;
Autor = Pablo Perez;
Autor = Maria Lopez
Algunas versiones nos dan la primera solucin y preguntan si deseamos el resto, en otras es
necesario colocar un ; despus de cada una para obtener la prxima. En estas ltima si damos
<enter> cancela y no muestra ms respuestas.
Veamos otro caso. Asumamos que existen los siguientes hechos en la base de datos:
autor( Juan Perez, Geografia, EUDEBA, 23.60).
autor( Raul Bento, Geografia, EUREKA, 35.26 ).
autor( Luisa Craso, Geografia, LIMUSA, 23.69).
y preguntamos:
?- autor( Autor, Geografia, Editor, Precio ).
nos responder:
Autor =Juan Perez
Editor =EUDEBA
Precio = 23.6 ;
Autor =Raul Bento
Editor =EUREKA
Precio = 35.26 ;
Autor = Luisa Craso
Editor = LIMUSA
Precio = 23.69

1.8. Estructuras
Una variable no puede instanciar un nombre de predicado. No obstante, podemos solucionar
esto valindonos de la posibilidad de poder anidar estructuras. Por ejemplo:
libro( autor( Sandra Muriel, Perros, EUDEBA, 45.56)).
Cada argumento de un predicado es un trmino, pero a su vez este puede estar formado por
otro. Observemos la estructura que se detalla en el diagrama de abajo, all aparece el concepto de
functor, el cual no es otra cosa que el trmino que precede al parntesis de apertura de la lista de
argumentos del predicado.

En la mayora de las versiones de PROLOG, un functor puede ser instanciado con una
variable. Por ejemplo:
?- libro( Relacion( Sandra Muriel, Perros, EUDEBA, 45.56)).
nos da como resultado:
Relacion = autor
Veamos un ejemplo ms complejo:
libro( autor( nomyape( apellido(Perez), nombre(Juan))), titulo(Algebra),
descripcion( editorial(EUDEBA), fecha(1986), precio(36.56)).

Ahora cuando preguntemos, podemos substituir con variables cualquier trmino de la
pregunta, que sea un argumento de un predicado o incluso por el nombre de este. Por ejemplo,

podramos buscar el Autor que se apellida Perez de un libro de Algebra:
?- libro( autor( nomyape( apellido(Perez), nombre(Nombre))), titulo(Algebra),
descripcion( editorial(Editor), fecha(Fecha), precio(Valor)).
y la respuesta ser:
Nombre=Juan
Editor=EUDEBA
Fecha=1986
Valor=36.56
Ahora si preguntamos:
?- libro( Autor, Titulo, Orden ).
nos responde:
Autor = nomyape( apellido( Perez ), nombre ( Juan ))
Titulo = titulo( Algebra )
Orden = descripcion ( editorial( EUDEBA ), fecha( 1986 ), precio(36.56)
Veamos un ejemplo ms. Supongamos el siguiente hecho:
animal( pajaro( marino( gaviota( blanca )))).
Podemos efectuar diversas preguntas a partir de este hecho y obtener las respuestas que se
indican a continuacin de cada una:
?- animal( Animal ).
Animal = pajaro( marino( gaviota( blanca )))
?- animal( pajaro( Pajaro )).
Pajaro = marino ( gaviota ( blanca ))
?- animal( pajaro( marino( Marino)))
Marino = gaviota ( blanca )
?- animal( pajaro( marino( gaviota ( Gaviota))))
Gaviota = blanca
1.9. Tratamiento de listas
Supongamos que en la base de datos del sistema est almacenado el siguiente hecho:
le_gusta( alfredo, chocolate, dulce, helado ).
y que deseamos saber si a alfredo le gusta el man:
?- le_gusta( alfredo, man).
el sistema nos responder: no
ahora si preguntamos por.

?- le_gusta( alfredo, Que ).
PROLOG nos responder: no
Esto se debe a que la pregunta no coincide con el hecho, ya que nuestra pregunta tiene dos
argumentos y la regla tienen cuatro. Lo que necesitaramos es poder indicar en el segundo
argumento un conjunto de valores, en lugar de uno slo. Para eso podemos escribir:
le_gusta( alfredo, [ chocolate, dulce, helado ] ).
Al encontrar los corchetes PROLOG interpreta que se trata de una lista de valores. Sin
embargo, si hacemos la pregunta otra vez:
?- le_gusta( alfredo, helado ).
nos responder: no
pero si la hacemos as:
?- le_gusta( alfredo, Que ).
nos dir:
Que = [ chocolate, dulce, helado ]
Esto se debe a que PROLOG trata una lista, como un nico argumento. Entonces, lo que
necesitamos es poder acceder individualmente a cada de elemento. Para esto contamos con un
operador | (pipe) que nos permite dividir una lista en cabeza y cola. Entendindose por cabeza, al
primer elemento de la lista y por cola, a la lista formada por el resto. Entonces ahora:
?- le_gusta( alfredo, [ Cabeza | Cola ] ).
nos responde:
Cabeza = chocolate
Cola = [ dulce, helado ]
Notemos que hemos usado el smbolo |, para separar la cabeza de la cola de la lista. Luego si
preguntamos:
?- le_gusta( alfredo, [ X, Y | Z ] ).
el sistema contestar:
X = chocolate
Y = dulce
Z = [ helado ]
o para:
?- le_gusta( alfredo, [ W, X, Y | Z ] ).
obtendremos:
W = chocolate
X = dulce
Y = helado

Z = []
La cola de una lista es siempre una lista. En otras palabras, cuando nosotros le damos a
PROLOG una lista o una parte de ella, expresndola mediante el operador |, lo que hace es dividir
la lista en dos partes, la primera ubicada a la izquierda del signo la toma como la cabeza, y el resto
lo considera la cola de la lista original. Si al efectuar esta separacin la segunda lista no tiene
elementos (como en el ejemplo anterior) asume que es la lista vaca []. Veamos algunos ejemplos de
listas y de sus esquemas de separacin en cabeza y cola:
Se define Lista Cabeza Cola
lista de tres elementos [3, 5, 7] 3 [5, 7]
lista de dos elementos [3, 5] 3 [5]
lista unitaria [ a ] a [ ]
lista vaca [ ] indefinido indefinido
lista de listas [ [1,2,3], [1,2], [ ] ] [1,2,3] [ [1,2], [ ] ]
equivale a [3,6,7] [ 3 | [6, 7] ] 3 [6, 7]
lista de smbolos [dia,mes,anio] dia [mes, anio]
lista de cadenas [luis,juan,ana] luis [juan,ana]
lista de reales [3.4,5.6,0.0] 3.4 [5.6,.0.]

Las listas referenciadas con variables, se asocian con los valores del siguiente modo:
Lista Referencia con variables Vinculacin con cada variable
[uno,dos,tres] [X,Y,Z] X=uno, Y=dos, Z=tres
[7] [X | Y] X=7, Y=[]
[1,2,3,4] [X, Y | Z] X=1, Y=2, Z=[3,4]
[ [1,2], [3,4] ] [ X | Y ] X=[1,2], Y=[3,4]
1.9.1. Predicado fail y variables annimas
Si bien los conceptos de predicado fail y variable annima, no se relacionan slo con listas,
usaremos este tema para introducir ambos conceptos. Una variable annima se utiliza en aquellas
situaciones en las cuales, existe un valor que no se requiere instanciarlo en forma explcita.
El siguiente conjunto de reglas, especifica la lgica de solucin del problema de buscar un
elemento (no repetido) en una lista, para conocer su posicin.
Sea la relacin posicin(X, L, N), cuyo significado es: N es la posicin del elemento X
dentro de la lista L.
Definimos un hecho que nos pueda servir de axioma para solucionar el problema. Para
esto nos plateamos la situacin de que el valor buscado, sea la cabeza de la lista, entonces
podemos afirmar que el valor buscado ocupa la primera posicin de la lista:
posicion(X, [X|C], 1).
Observe que en este caso, afirmando categricamente que el valor buscado es el primero de
la lista, no interesa instanciar el valor del resto (cola) de la lista, por lo que el predicado puede
expresarse usando _ que es el smbolo que indica que se trata de una variable annima:
posicion(X, [X|_], 1).
Donde el guin de subrayado, expresa que se trata de una variable annima, cuyo valor no

interesa.
Luego la posicin de un elemento cualquiera queda dada por la relacin que expresa, que un
valor X, que no ocupa la primera posicin dentro de una lista, se ubica en una posicin N si y
solo si se cumple que el elemento se ubica en la posicin N 1, dentro de la sublista que resulta de
descartar la cabeza de la lista. Observe que en este caso s interesa instanciar el valor de la cola de
la lista:
posicion(X, [P|C], N) :- posicion(X, C, M), N is M + 1.
Pero que ocurre en el caso que el valor buscado no exista dentro de la lista? Podramos
adoptar como convencin indicar que se ubica en la posicin 0 (cero) y expresar esto as:
posicion(X, [], 0).
El problema es que esto es falso, porque en realidad el valor no existe, por lo tanto este
predicado siempre que se evale debe ser falso. Por esto debemos re-escribirlo usando el predicado
predefinido fail que garantiza que una regla falle.
posicion(X, [], 0) :- fail.
Aqu tambin el valor de la posicin no interesa, dado que la regla fracasa:
posicion(X, [], _) :- fail.
1.9.2. Tratamiento de listas
La manipulacin de listas frecuentemente requiere hacer uso de las tcnicas recursivas. Ya
que estas nos permiten dividir una lista en la cabeza y cola, hacer algo con la cabeza y entonces
dividir la cola, en una nueva cabeza y cola, para aplicarle a estas el mismo tratamiento, y as
sucesivamente hasta que en algn momento la cola est vaca.
De esta manera, los elementos de una lista pueden imprimirse usando un proceso recursivo.
Para esto se separa la lista en cabeza y cola, entonces se imprime la cabeza, luego se toma la cola y
se aplica el mismo procedimiento. En cada etapa se verifica que la cola no est vaca, cuando esta lo
est termina el procesamiento. La representacin de este problema es as:
mostrar_lista( [] ).
mostrar_lista( [ Cabeza | Cola ] ):-
write( Cabeza),
nl,
mostrar_lista( Cola ).

Ahora supongamos que damos como meta:
?- mostrar_lista( [papa, tomate, pescado] ).
[ ]
1. mostrar_lista( [papa, tomate, pescado] ).
cabeza cola
2. mostrar_lista( [papa | [tomate, pescado] ]) :-
cabeza
write( papa ),
nl,
Si la lista es vaca, se detiene el proceso, ya que la meta se satisface.

Para imprimir la lista, se escribe el valor correspondiente a la
cabeza de la misma (usando el predciado write), luego se realiza el
predicado nl (new line) y entonces.

Se vuelve a aplicar el mismo proceso pero a la cola de la lista
El primer predicado definido mostrar_lista, es
tratado y falla, ya que la lista no est vaca,
entonces PROLOG intenta con el segundo
predicado que ha sido definido.

La cabeza del segundo predicado coincide con
la pregunta, por lo tanto las metas que estn
en el cuerpo de esta regla son tratadas.

cola
mostrar_lista( [ tomate, pescado] ).
[ ]
1. mostrar_lista( [ tomate, pescado] ).
cabeza cola
2. mostrar_lista( [tomate | pescado] ) :-
cabeza
write( tomate ),
nl,
cola
mostrar_lista( [pescado] ).
[ ]
1. mostrar_lista( [pescado] )
cabeza cola
2. mostrar_lista( [pescado | [ ] ] ) :-
cabeza
write( pescado ),
nl,
cola
mostrar_lista( [ ] ).
[ ]
1. mostrar_lista( [ ] ).

Veamos ahora un programa que contiene los hechos y reglas necesarios para determinar si
un elemento pertenece o no, a una lista de nmeros enteros.
pertenece( NRO, [NRO | _ ] ). este hecho afirma que un valor pertenece a una
lista, si el mismo, es la cabeza de la lista
pertenece(NRO , [ _ | COLA ] ) :- pertenece( NRO, COLA ). esta regla indica que si un valor no es la cabeza de
una lista, pero pertenece a la cola de la lista,
entonces pertenece a la lista
Ahora si indagamos por:
?- pertenece( 5, [1,2,3,4,5,7,8,9] ) nos responde que es verdad
?- pertenece( 6, [1,2,3,4,5,7,8,9] ) nos responde que es falsa
? Verificar el programa, y efectuar el desarrollo del anlisis para el proceso de inferencia llevado
a cabo por el lenguaje.
Modifiquemos el programa anterior para contar los elementos de la lista.
pertenece( NRO, [NRO | _ ] ).
Esta ltima lnea, aplica el tratamiento de la
meta original, pero aplicndola a la sublista
formada por la cola de la original.

Ahora se sigue el mismo proceso anterior.

Aqu se intenta verificar la meta original para
la lista vaca, ahora el primer predicado si es
verdadero, por lo que PROLOG ha satisfecho
completamente la meta original.

pertenece(NRO , [ _ | COLA ] ) :- pertenece( NRO, COLA ).
cantidad( 0, [] ). este hecho afirma que la cantidad de elementos de
la lista vaca, es igual a cero
cantidad( N, [ _ | C] ) :- cantidad(X, C), N = X + 1. esta regla indica que la cantidad de elementos de
una lista cualquiera, es igual a un valor N, si y solo
si, se cumple que la cantidad de elementos de la
cola es igual a un valor X, y adems se cumple que
N es igual a X ms 1
? Explicar la regla para contar.
Ahora modifiquemos el programa para que se pueda concatenar una lista con otra, y obtener
el resultado en una tercera lista.
pertenece( NRO, [NRO | _ ] ).
pertenece(NRO , [ _ | COLA ] ) :- pertenece( NRO, COLA ).
cantidad( 0, [ ] ).
cantidad( N, [ _ | C] ) :- cantidad(X, C), N = X + 1.
concatenar( [ ], L, L ). este hecho afirma que si a una lista vaca, la
concateno con una lista cualquiera no vaca, la lista
resultante es la misma lista no vaca
concatenar( [P | C], L, [P | LL] ) :- concatenar( C, L, LL ). esta regla indica que si tengo una lista formada por
una cabeza P y una cola C, y la concateno a otra, la
lista resultante esta formada por la cabeza de la
primera y una cola LL, si y solo si, se cumple que LL
es el resultado de concatenar la cola C a la lista L
? Explicar los hechos y reglas correspondientes a la regla concatenar.
? Incorporar los hechos y reglas necesarias para:
1. Obtener la lista invertida.
2. Sumar los elementos de la lista.
3. Insertar un elemento en la lista.
4. Extraer un elemento de la lista.
5. Obtener el mayor elemento de la lista.
6. Obtener el menor elemento de la lista.
7. Insertar en orden un elemento en la lista.
8. Ordenar la lista.
1.9.3. Estructuras y listas
Podemos poner en una lista estructuras ms complejas que las que vimos anteriormente. En
el siguiente ejemplo se ha desagregado el esquema, para mostrar qu se incluye, en cada nivel de
anidamiento de la definicin de la lista.
catalogo( [ libro( autor(juan), titulo(algebra) ),
libro( autor(luis), titulo(historia) ),

libro( autor(maria), titulo(fisica) ) ] ).
As si preguntamos:
?- catalogo( [Pro | Resto ] ).
PROLOG responder:
Pro = libro( autor(juan), titulo(algebra) )
Resto = libro( autor(luis), titulo(historia) ),
libro( autor(maria), titulo(fisica) )
Podemos preguntar cosas ms complejas como:
?- catalogo( [ libro(autor(Autor),titulo(Titulo) | Resto ] ).
y obtendremos:
Autor = juan
Titulo = algrebra
Resto = libro( autor(luis), titulo(historia) ),
libro( autor(maria), titulo(fisica) )
Si deseramos conocer si un tem existe o no en la lista, podemos escribir una regla como
hicimos antes a modo de ejemplo, sin embargo muchas versiones de PROLOG ya traen incorporado
un predicado para esto. Veamos este ejemplo:
?- member( Lista ), member( helado, Lista ).
aqu lo que estamos diciendo es que encuentre una coincidencia del predicado e instncie su
lista en la variable Lista, pero slo si helado es miembro de esta.
Otra pregunta que podemos hacer es:
?- member( helado, [chocolate, dulce, helado] ).
y la respuesta ser: yes
Tambin:
?- member( Que, [chocolate, dulce, helado] ).
Que = chocolate
Que = dulce
Que = helado
Que = []
1.10. Cadenas de caracteres
PROLOG interpreta cualquier tomo como una unidad inseparable. Por ejemplo:
mayor_de
catalogo
hace fro
No hay forma de conseguir separar alguno de sus componentes, aunque si podemos

manipular los mismos. Por ejemplo:
Agregar la palabra muy a la frase Estoy hambriento, para formara la frase Estoy
muy hambriento
Eliminar las letras mente, de la palabra hbilmente para formar hbil
Esto lo podemos hacer si tratamos esas palabras como cadenas. Para esto debemos encerrarlas
entre comillas simples:
Estoy hambriento
hbilmente
Internamente una cadena es tratada como una lista de nmeros, que se corresponden con los
valores de la tabla ASCII. En algunas versiones si encerramos entre doble comillas dobles, las
cadenas son mostradas como secuencias de enteros (el equivalente ASCII).
1.11. Relacionadores lgicos y variables annimas
Si asumimos los siguientes hechos:
autor( Juan Perez, Geografia, EUDEBA, 23.60).
autor( Raul Bento, Geografia, EUREKA, 35.26 ).
autor( Luisa Craso, Geografia, LIMUSA, 23.69).
nacionalidad(Juan Perez,Argentino).
nacionalidad(Raul Bento,Argentino).
nacionalidad(Luisa Craso,Peruano).
e indagamos por el nombre de autores que tienen libros sobre Geografia y que son
argentinos, obtenemos:
?- autor( Nombre, Geografia, _, _ ), nacionalidad( Nombre, Argentino ).
Aqu hemos empleado la coma para indicar que nuestra pregunta implica una conjuncin
lgica de los dos predicados.
El guin de subrayado _ empleado, expresa que las dos ltimas son variables annimas. Esto
significa que conocemos que en la estructura existen esos dos ltimos argumentos, pero no nos
interesa referirlos explcitamente. En otras palabras es que no nos interesa almacenar esos variables
en dos variables que podamos referir especficamente, pero no podemos evitar colocarlos debido a
que hay que respetar la estructura de la clusula.
Nombre = Juan Carlos
Nombre = Raul Bento
Del mismo modo podemos emplear el relacionador punto y coma, para expresar la
disyuncin lgica. Por ejemplo si deseamos preguntar el nombre de autores que de la editorial
EUDEBA o LIMUSA, deberamos escribir:
?- autor( Nombre, _, EUDEBA, _ ); autor( Nombre, _, EUREKA, _ ).
entonces PROLOG contestar:

Nombre = Raul Bento
Si queremos saber quienes son los autores de libros de Geografia de nacionalidad
Argentino o Peruano, debemos preguntar as:
?- autor( Nombre, Geografia, _, _ ), ( nacionalidad( Nombre, Argentino );
nacionalidad( Nombre, Argentino ) ).
los parntesis adicionales son necesarios para agrupar los predicados involucrados en la
disyuncin lgica, sobre la conjuncin. Luego la respuesta es:
Nombre = Raul Bento
Nombre = Luisa Craso
El relacionador Y tiene preponderancia sobre el O, y el NOT sobre ambos.
Analicemos lo siguiente.
?- hecho(A), hecho(B), hecho(C); hecho(D), hecho(E).
Para resolver esto deben satisfacerse los hechos A y B y C o los D y E, en la figura se
muestra el esquema de anlisis:

Ahora si utilizamos parntesis para alterar la jerarqua tenemos.
?- hecho(A), hecho(B), ( hecho(C); hecho(D), hecho(E) ).
En este caso resuelve A y B y ( C o D y E ).

Veamos otro caso.

?- hecho(A), hecho(B), hecho(C);
hecho(D), hecho(E), hecho(F), hecho(G);
hecho(H), hecho(I).
Esto es tratado como se muestra en el diagrama:

Analicemos otra situacin.


?- hecho(A), hecho(B), ( hecho(C); hecho(D) ), hecho(E), hecho(F), hecho(G);
hecho(H), hecho(I).

Estudiemos la siguiente situacin.
Es importante comprender bien el uso del relacionador O, y los nombres de variables.
es_ hermana_de( Laura, Benito ).
es_hermana_de( Maria, Benito ).
si pedimos que nos devuelva los nombres de las hermanas de Benito, preguntando por la
primera hermana de l y por la segunda, tendramos:
?- es_hermana_de( PraHermana, Benito ), es_hermana_de( SdaHermana, Benito )
la respuesta es:
PraHermana=Laura
SdaHermana = Laura
PraHermana=Laura
SdaHermana = Maria
PraHermana=Maria
SdaHermana = Laura
PraHermana=Laura
SdaHermana = Laura
Lo cual no es la respuesta que esperamos. Esto se debe a que usamos variables distintas y
ambas pueden instanciar la misma constante, ya que por ejemplo Maria puede ser considerada como
la primera o la segunda hermana, al mismo tiempo. Para evitar este tipo de problemas podemos
agregar un predicado a la regla que impida esto.
?- es_hermana_de( PraHermana, Benito ),

es_hermana_de( SdaHermana, Benito ),
not( PraHermana = SdaHermana).
Aqu el uso del predicado predefinido not nos ayuda a evitar que los nombres sean
considerados dos veces. Entonces la respuesta ser:
PraHermana=Laura
SdaHermana = Maria
PraHermana=Maria
SdaHermana = Laura
Las respuestas son lgicas, a pesar de ser redundantes.
Analicemos este otro caso.
Asumamos estos hechos:
nacionalidad( Juan Carlos, Argentino ).
autor( Marcos Perez, Economia ).
y preguntemos:
?- nacionalidad( _, Argentino ).
responder: yes pero no Juan Carlos.
Esto ltimo, se debe al uso de la variable annima, ya que esta no es instanciada, por lo que
no regresa valor.
Ahora si consultamos por:
?- nacionalidad( _, Argentino ), autor( _, Economia ).
quizs esperemos que nos diga: no ya que no hay un Argentino que haya escrito un libro
de Economia, sin embargo contesta yes.
Esto se debe a que la pregunta efectuada, al estar formada con variables annimas, las cuales
no son instanciadas, expresa lo siguiente: Existe alguien cuya nacionalidad es Argentino, y existe
alguien que es autor de un libro de Economia?
Ambos hechos por separado son verdaderos, ya que s existe alguien de nacionalidad
Argentino y s existe alguien que ha escrito un libro de Economia.
1.12. Base de datos y bsqueda de objetivos
Si hemos definido en la base de datos del sistema el siguiente conjunto de hechos y reglas:
nacionalidad( Alfredo, Argentino ).
nacionalidad( Jaime, Uruguayo ).
nacionalidad( Beto, Chileno ).
nativo_de( Alfredo, Sudamericana ).
nativo_de( Jaime, Sudamericana ).
nativo_de( Beto, Sudamericana ).

nativo_de( Persona, Sudamericano ):-
nacionalidad( Persona, Argentino );
nacionalidad( Persona, Uruguayo );
nacionalidad( Persona, Chileno ).
Luego al preguntar:
?- nativo_de( Alfredo, Sudamericano ).
o
?- nativo_de( Jaime, Sudamericano ).
o
?- nativo_de( Bety, Sudamericano ).
Observemos que la variable Persona en la regla, va a ser instanciada para diferentes
personas (Alfredo, Jaime, Bety), para cada pregunta que sea procesada. As como equipara una
pregunta con un hecho en su base de datos, PROLOG equipara una pregunta con una regla.
Para la primera, la parte ubicada a la izquierda del signo de implicacin coincide con la
pregunta, entonces la variable Persona es instanciada con el valor Alfredo, y el segundo argumento
es Sudamericano, entonces la cabecera de la regla queda as:
nativo_de( Alfredo, Sudamericano ):-
...
entonces tan pronto como la variable Persona instancia el valor Alfredo, en la cabecera de la
regla, la misma variable tambin es instanciada con Alfredo donde quiera que aparezca en el cuerpo
(parte derecha) de la regla.
De este modo la regla queda:
nativo_de( Alfredo, Sudamericano ):-
nacionalidad( Alfredo, Argentino );
nacionalidad( Alfredo, Uruguayo );
nacionalidad( Alfredo, Chileno ).
pero antes de que la regla pueda ser considerada como verdadera y por lo tanto que el
sistema conteste yes, el cuerpo de la regla debe ser verdadero, y este ltimo slo va a ser evaluado
como cierto si se puede encontrar un hecho (o una regla) que indique que Alfredo efectivamente es
Argentino, Uruguayo o Chileno.
Para esto se empieza a recorrer la base de datos desde el comienzo, hasta que se encuentra el
hecho:
por lo tanto el cuerpo de la regla es verdadero y se puede implicar que la cabecera tambin
lo es, entonces el sistema responde: yes.
Ahora se muestra un esquema donde, las lneas llenas indican la secuencia de bsqueda de
objetivos y las lneas de trazos, la secuencia de regreso (metas satisfechas).

?- es_nativo(Alfredo, Sudamerica). VERDAD
es_nativo(Alfredo, Sudamerica) :-
nacionalidad( Alfredo, Argentino );
nacionalidad( Alfredo, Uruguayo);
nacionalidad( Alfredo, Chileno ).

nacionalidad( Jaime, Uruguayo ).
nacionalidad( Beto, Chileno ).
Veamos otro ejemplo un poco ms complejo, para indagar por el culpable de un delito
1
:
posible_sospechoso( alfredo ).
posible_sospechoso( maria ).
posible_sospechoso( luisa ).
posible_sospechoso( george ).
delito( robo, juan, jueves, parque).
delito( estafa, raul, jueves, bar ).
delito( robo, jorge, lunes, bar ).
estaba_en( alfredo, jueves, parque ).
envidia_a( alfredo, juan ).
principal_sospechoso( Persona, Delito ):-
delito( Delito, Victima, Fecha, Lugar ),
posible_sospechoso( Persona ),
estaba_en( Persona, Fecha, Lugar ),
tiene_motivo( Persona, Victima ).
principal_sospechoso( desconocido, Delito ).
tiene_motivo( Persona, Victima ):-
envidia_a( Persona, Victima );
debe_a( Persona, Victima ).
si preguntamos:
?- principal_sospechoso( alfredo, robo ).
PROLOG tratar de encontrar en su base de datos un predicado que coincida (es decir un
hecho o una regla cuya cabecera coincida con la pregunta). Si encuentra una regla, se trata de
verificar todas las condiciones de la regla, es decir todos los predicados (hechos o reglas) que
siguen al signo de implicacin.

1
PROLOG Programming de Nigel Ford - John Wiley & Sons Ltd.

Como no existe un hecho que cumpla lo anterior, se trata de encontrar una regla. Si la
encuentra, se intenta verificar todas las condiciones de la misma.

La cabecera de la regla coincide con la pregunta, por lo tanto se pasan los valores dados en
la pregunta, a las variables en esta regla, que ahora queda as:
principal_sospechoso( alfredo, robo ):-
delito( robo, Victima, Fecha, Lugar ),
posible_sospechoso( alfredo ),
estaba_en( alfredo, Fecha, Lugar ),
tiene_motivo( alfredo, Victima ).
Antes de poder contestar yes o no a la pregunta original, se deben verificar todas las
declaraciones de la parte derecha de la regla. En otras palabras se trata cada predicado que aparece
all, como una meta, intentando satisfacerlo. Para esto ltimo, se instancia el valor de cada variable
que forma parte de los argumentos del predicado. El cuerpo de la regla se analiza de izquierda a
derecha, si hay ms de un de un predicado.
En nuestro caso la primera meta a ser satisfecha es:
delito( robo, Victima, Fecha, Lugar )
Se intenta encontrar este hecho en la base de datos y el primero que encuentra es:
delito( robo, juan, jueves, parque ).
As es que se instancian las variables de la meta, con los valores del hecho encontrado. La
meta delito en la regla principal_sospechoso ahora se satisface, entonces la regla completa queda
en:
principal_sospechoso( alfredo, robo ):-
delito( robo, juan, jueves, parque ),
posible_sospechoso( alfredo ),
estaba_en( alfredo, jueves, parque ),
tiene_motivo( alfredo, juan ).
La meta delito se satisface y los valores de las variables Victima, Fecha y Lugar, se han
reemplazado en todos los lugares donde aparecen en esta regla. La prxima meta a ser satisfecha es
la de posible_sospechoso( alfredo ). Entonces se busca un predicado que coincida en la base de
datos, y se encuentra:
posible_sospechoso( alfredo ).
Esta es satisfecha con xito y se va sobre la meta estaba_en( alfredo, jueves, parque ).

Nuevamente, se encuentra una coincidencia en la base de datos y se pasa a la siguiente, que es
tiene_motivo(alfredo, Victima). En este caso no se logra encontrar ningn hecho que coincida, pero
si se encuentra una regla. Por lo tanto se pasan los valores de la meta a la regla, la cual queda as:
tiene_motivo( alfredo, juan ):-
envidia_a( alfredo, juan );
debe_a( alfredo, juan ).
Esta regla slo puede ser satisfecha, cuando su cabecera lo sea y esta slo lo estar, cuando
todas las condiciones en el cuerpo de la regla sean satisfechas. Esto ocurre si Alfredo tiene celos de
Juan, o si Alfredo adeudaba dinero a Juan. Por lo tanto se intenta encontrar un predicado que
coincida con:
envidia_a( alfredo, juan )
Como se encuentra una coincidencia en la base de datos, la regla queda probada, por lo que
la meta principal_sospechoso se satisface. Ahora todas las metas que estn en la parte derecha de la
regla quedan satisfechas, por lo tanto la cabeza de esta se satisface y tambin nuestra pregunta
original, entonces la respuesta final es: yes.
En el siguiente diagrama se muestra la secuencia de evaluacin de las metas y submetas, que
resuelven este problema.

Ahora vamos a preguntar lo siguiente:
?- principal_sospechoso(Quien, robo).


Por lo que finalmente la respuesta del sistema ser: Quien = alfredo
1.13. Backtracking
Siempre que una meta falla porque no puede ser satisfecha, o sea que no encuentra ningn
predicado que coincida con ella, el sistema automticamente retrocede a la meta previa, para ver
si esta puede ser re-satisfecha por otro camino. Si no se puede, se regresa a la anterior a esta

ltima para intentar lo mismo, y as sucesivamente. A este mecanismo de retroceso en busca de
metas previas se le denomina backtracking y es, una de las caractersticas principales de
PROLOG. Mediante el mismo lo que hace el sistema, es agotar todas las posibilidades de
exploracin de los hechos y reglas existentes en la base de datos, para intentar satisfacer una meta.
Volvamos sobre el caso previo que hemos analizado, pero ahora vamos a suponer que el
hecho: estaba_en( alfredo, jueves, parque ) ha sido retirado de la base de datos (borrado), por lo
tanto no existe. Nuevamente, para la pregunta:

?- principal_sospechoso(Persona, robo).
lo que hace el sistema es indagar con la regla:
y convirtindola en:
principal_sospechoso( Persona, robo ):-
delito( robo, Victima, Fecha, Lugar ),

En la pregunta se ha especificado que el valor de la variable Delito debe ser robo, este dato
se comporta como una constante, por lo tanto no puede cambiarse. Entonces el sistema lo que debe
hacer es buscar coincidencias, pero manteniendo ese valor fijo, por lo que bajo ningn motivo
puede llegar a buscar para otro tipo de delito.
Ahora, todo esto no se cumple para los trminos donde figuran variables, como en el caso de
Persona. Por lo tanto, lo que se har es procurar satisfacer la meta para los distintos sospechosos
que estn almacenados en la base de datos. Si luego de esto no se satisface el objetivo, lo que hace
el sistema es retroceder para intentar satisfacer la meta previa buscando otro robo. Entonces
tambin para este, se intenta con todos los sospechosos de los delitos de robo que se encuentran en
la memoria y as se contina hasta agotar los delitos.
En el siguiente diagrama se muestra el proceso completo. La lnea llena se refiere al
requerimiento efectuado para satisfacer una meta determinada. La de trazos, indica cul es la
informacin suministrada para el objetivo que se est evaluando y finalmente, la lnea gruesa indica
el camino seguido por el proceso de backtracking.





Como se puede ver, cuando retrocede de esta manera, PROLOG recuerda que predicados
de la base de datos han sido tratados. As se evita que se vuelva a intentar satisfacer una meta con
hechos que ya fueron considerados, quedando en un ciclo sin fin.
Tambin observemos que la meta slo se acepta como fracasada, cuando se probaron todas
las alternativas posibles. Esto es, si todos los sospechosos posibles se investigan y fracasan, an as
no se finaliza, ya que se intenta con el segundo predicado principal_sospechoso. Este proceso es
similar al que se lleva a cabo cuando se intenta con los nombres de sospechosos, la diferencia es
que en este caso se trata de predicados.
En nuestro caso existe otro predicado, principal_sospechoso( desconocido, Delito ), que
coincide con la estructura de la pregunta, entonces la misma se resuelve como se muestra a
continuacin:
la pregunta original ?- principal_sospechoso(Persona, robo).
y este segundo predicado coinciden,
entonces cualquier variable automticamente
instancia a la constante que aparece en la misma
posicin en la sentencia coincidente principal_sospechoso(desconocido, Delito).

Aunque este segundo predicado es un hecho y no una regla, su estructura coincide con la de
la pregunta. La instanciacin de variables y constantes tiene lugar del siguiente modo:
Persona
?- principal_sospechoso(desconocido, robo).

Delito
principal_sospechoso(desconocido, robo).
por lo tanto PROLOG contesta que el sospechoso es: desconocido

Cuando hemos definido varios predicados del mismo tipo (hechos y/o reglas), cada uno de
ellos es tratado por el sistema para intentar satisfacer la meta que se busca. Pero debemos tener en
cuenta que la bsqueda en la base de datos se hace en orden secuencial desde arriba hacia abajo y
si, hubiramos colocado el segundo predicado (hecho) en primer lugar, este se habra encontrado
primero y por lo tanto el otro (regla) no se analizara.
En algunos casos, dependiendo de la ubicacin de los hechos y reglas en la base de datos, puede
alterarse el comportamiento de un programa.
1.14. Operador de corte
A veces podemos necesitar controlar la manera en que PROLOG realiza backtracking. Por
ejemplo puede requerirse que una vez que se pas de cierto punto, no se pueda retroceder a buscar
otra meta.
Veamos un ejemplo sencillo para entender esto. Supongamos los hechos y reglas necesarios
para satisfacer la meta de, ir a la casa de otra persona en micro, desde Godoy Cruz a Lujn para

visitarla, seran los siguientes:
1. Consiga un micro que vaya desde Godoy Cruz a Lujn.
2. Hacer sonar el timbre en la casa.
Ahora imaginemos que la regla 1 se satisface, pero la 2 fracasa (porque no hay nadie en
casa). No tendra sentido intentar con la primera nuevamente, tomando otro micro, ya que el
problema por el cual no se pudo satisfacer el objetivo global no es ese.
Entonces lo que necesitamos aqu, es poder indicarle al sistema que no vuelva a intentar con
la meta previa, o sea que no haga backtracking.
Esto es posible mediante el uso del operador de corte ! ('cut'):
1. Consiga un micro que vaya desde Godoy Cruz a Lujn.
2. !
3. Hacer sonar el timbre en la casa.
El operador ! es interpretado por el sistema, como una indicacin que le dice que una vez
que se ha pasado del punto donde este aparece, no puede retroceder ms, para intentar satisfacer una
meta que se encuentre ms arriba.
Ahora veamos como podemos mejorar nuestro programa para encontrar sospechosos. Lo
que necesitamos es indicar es que, una vez que prob con todos los nombres de sospechosos, no
retroceda para buscar otra meta delito. Para esto lo que haremos es colocar el operador !,
inmediatamente despus de ese predicado en la regla correspondiente:
principal_sospechoso( Persona, Delito ) :-
!,
Ahora en el esquema que figura ms abajo se detalla como se lleva a cabo el proceso. En el
mismo, las zonas recuadradas sealan las partes del programa que no son accesibles debido al
operador de corte. As, si toda la gente tratada como sospechosos primarios fracasa, no se
retroceder para tratar de encontrar otro delito de robo. Sin el ! se hubiera hecho la sustitucin con
el segundo delito, intentando satisfacer la nueva meta.
Tambin observemos que la cabecera de la regla est ubicada antes del !, por lo que
tampoco no se puede retroceder hasta ella para tratarla nuevamente. En otras palabras, si una meta
que contiene un ! falla, entonces la meta entera fracasa, an cuando haya otras reglas o hechos que
pudieran ser tratados. Entonces ante la pregunta:
?- principal_sospechoso( Persona, robo ).
Al intentar probar la parte derecha de la regla, PROLOG va a encontrar el primer predicado
delito( Delito, Victima, Fecha, Lugar ), para lo que va a instanciar las variables con los valores
correspondientes y luego, realiza la bsqueda de un hecho de robo en la base de datos.
Posteriormente, cuando contine procesando la regla se va a encontrar con el !, el cual es siempre
verdad, pero le indica al sistema que a partir de ese punto ya no puede regresar.


En este caso, dado que para la primera regla no se encontr ningn sospechoso, PROLOG
no buscar el segundo predicado principal_sospechoso, por lo que no contestar:
Persona = desconocida
en vez de esto, la meta entera fracasa y nos da como respuesta: no
Si quisiramos mantener el !, pero a la vez posibilitar que el sistema conteste eventualmente

con Persona = desconocida, podramos agregar al programa original un predicado como el que
sigue:
identificar( Persona, Delito ):-
principal_sospechoso( Persona, Delito ).
identificar( desconocido, Delito).
...
entonces si preguntamos:
?- identificar( Persona, robo ).
y asumimos que no se encuentra ningn sospechoso, el ! slo afecta a la regla que lo
contiene (principal_sospechoso) no al resto, por lo que un predicado de nivel superior no es
afectado; entonces al fallar el primer intento, el sistema va a tratar nuevamente con un segundo
predicado identificar, dando como respuesta:
Persona = desconocida

Veamos otro ejemplo de uso del !. Supongamos los siguientes hechos y reglas:
puede( ave, volar ).
es_un( gorrin, ave ).
es_un( canario, ave ).
es_un( avestruz, ave ).
es_un( pingino, ave ).
puede( Animal, Habilidad):-
es_un( Animal, Genero ),
puede( Genero, Habilidad ).
Esta regla dice que un Animal puede hacer lo expresado por la variable Habilidad, si es del
tipo Genero y es posible encontrar un predicado que confirme, que ese Genero tiene la Habilidad
indicada.
si preguntamos:
?- puede( gorrin, volar ).
la respuesta ser:
yes
sin embargo, si preguntamos:
?- puede( pingino, volar ).
obtendremos una respuesta incorrecta: yes
Esto pasa porque aunque no se puede encontrar un hecho que afirme que un pingino puede
volar, se aplica la regla puede, del siguiente modo: afirmando que un ave puede volar, y un

pingino es un ave.
Entonces lo que vamos a hacer es indicar que un ave puede volar, a menos que sea un
pingino o un avestruz. Para esto agregamos las siguientes reglas, antes de la regla puede que
existe en la base de datos:
puede( pingino, volar ) :- !, fail.
puede( avestruz, volar ) :- !, fail.
El predicado fail est predefinido y lo que hace es forzar a que una meta fracase.
Ahora veamos el siguiente esquema en que indica como se lleva a cabo el procesamiento de
nuestra pregunta:
PREGUNTA RESPUESTA DE PROLOG
?- puede( pingino, volar). NO
puede( pingino, volar) :- se ejecuta primero por estar ubicada antes de la otra
en la base de datos
!, PROLOG no puede retroceder a la parte recuadrada,
que se ubica arriba del cut
fail. este comando indica que se debe abandonar la meta,
normalmente se intentara satisfacerla probando con el
prximo predicado puede, pero el cut previene de esto
puede( pingino, volar) :-
es_un( pingino, ave),
puede( ave, volar).

1.15. Predicados predefinidos
Las implementaciones del lenguaje tienen una gran cantidad de operadores y predicados
predefinidos, que ofrecen facilidades para construir esquemas de evaluacin lgica, ms complejos
que los vistos hasta ahora. A continuacin se mencionan algunos de ellos.
findall(T, C, L)
Encuentra todas las instancias del trmino T para la cual el predicado C es verdad, e inserta los
valores de T en la lista L.
Por ejemplo:
ejecuta(delucia, guitarra, clasica).
ejecuta(papo, guitarra, rock).
ejecuta(soledad, guitarra, folclore).
ejecuta(piazzola, bandoneon, tango).
ejecuta(troilo, bandoneon, tango).
ejecuta(mores, piano, tango).

tangueros(L) :- findall(P, ejecuta(P, _, tango), L) .
Entonces si damos la meta:
?- tangueros(L).
Nos responde con: L = [piazzola, troilo, mores]
Construya la regla para evaluar los tangueros que tocan el bandonen.

forall(P, Q)
Para todas las instancias del predicado P, evala el predicado Q. Eso es que, para cada solucin que
se encuentre al evaluar a P, se evala a Q.
Veamos un caso sencillo, para describir la ubicacin relativa de cajas en el siguiente esquema:
9 5 7 8 3 2
La descripcin de la situacin en Prolog podra hacerse as:
estaAizq(9, 5).
estaAizq(5, 7).
estaAizq(7, 8).
estaAizq(8, 3).
estaAizq(3, 2).
esMasGrande(X, Y) :- X > Y, write(X); true.
quienes :- forall(estaAizq(X, Y), esMasGrande(X, Y)).
Aqu se evala el predicado estaAizq(X, Y), para cada uno de los hechos descriptos en el conjunto
de reglas, y por cada uno se evala esMasGrande(X, Y). Este ltimo si el valor de la izquierda es
mayor , lo muestra, sino evala siempre a verdadero.
Si damos la meta:
?- quienes.
Nos va a responder: 9, 8, 3
El predicado quienes es verdadero si se cumple que:
(X)(Y)( estaAizq(X, Y) => esMasGrande(X, Y))
Por qu se usa el operador ; en lugar del , en la regla esMasGrande?

T =.. L
Define una relacin entre una estructura o un tomo y una lista, donde L es una lista, de la cual la
cabeza es el functor de T que es un trmino, y la cola contiene los argumentos para T. De esta
forma lo que hace es mapear un trmino dentro de una lista.
Por ejemplo si damos:

?- X =.. [mas, 2, 3].
Devuelve X = mas(2,3), o sea que construy la estructura de un predicado o relacin.
En otro caso si damos:
?- findall(P,Q,S) =.. L.
El resultado es una lista construida: L = [findall, P, Q, S]
El siguiente ejemplo permite simplificar expresiones aritmticas bsicas de suma y producto.
Primero definimos los hechos y reglas, que describen las simplificaciones bsicas:
expresion(+, X, 0, X).
la suma de un valor y 0, da el valor
expresion(+, 0, X, X).

expresion(+, X, Y, Z) :- integer(X), integer(Y), Z is X + Y.
sumar 2 valores, da otro, si es una suma
expresion(+, X, Y, X+Y).
sub-expresin de suma
expresion(*, _, 0, 0).
el producto de un valor por 0, da 0
expresion(*, 0, _, 0).

expresion(*, 1, X, X).
el producto de 1 por un valor, da el valor
expresion(*, X, 1, X).

expresion(*, X, Y, Z) :- integer(X), integer(Y), Z is X * Y.
multiplicar 2 valores, da otro, si es un producto
expresion(*, X, Y, X*Y).
sub-expresin de producto
Luego definimos las reglas de simplificacin:
simplificar(E, E) :- atomic(E), !.
una expresin atmica simplificada, es la misma expresin
simplificar(E, F) :- E =.. [Op, L, R],
descompone la expresin es sus elementos
simplificar(L, X),
aplica recurrencia a la sub-expresin izquierda
simplificar(R, Y),
aplica recurrencia a la sub-expresin derecha
expresion(Op, X, Y, F).
obtiene el resultado de simplificar la expresin binaria bsica
Entonces si damos como objetivo:
?- simplificar(x + 0 * a + b * c, L).
Responde con la expresin simplificada: L = x + b * c


P Pa ar ra ad di ig gm ma a F Fu un nc ci io on na al l
Para el estudio de este paradigma es conveniente que repase los conceptos de relaciones y
funciones, estudiados en el curso de Matemtica Discreta.
2. PROGRAMACIN FUNCIONAL
A veces es difcil darse cuenta de las ventajas que aporta cierto modelo de programacin.
Por ejemplo, si estamos pensando en escribir un pequeo programa para leer los valores de dos
matrices de nmeros reales, multiplicarlas y mostrar la matriz resultante, lo ms probable es que
escribamos un programa en algn lenguaje estructurado del paradigma imperativo (Pascal, C,
Fortran, etc.). Ya que no le encontraremos sentido, al tener que estudiar un nuevo modelo de
programacin, para encarar la resolucin del problema.
Por qu alguien se tomara el trabajo de desarrollar un nuevo modelo de programacin?
Probablemente, porque considera que los modelos existentes no son adecuados para implementar la
solucin del tipo de problemas que necesita resolver. Luego podemos decir, que con el desarrollo
de cada paradigma se ha pretendido lograr una mejora en el proceso de construccin de programas.
Por ejemplo dentro del paradigma imperativo, con el modelo orientado a objetos, se
pretendi aumentar el nivel de abstraccin y la mantenibilidad de grandes programas. Para esto, se
mejoraron los medios para el encapsulamiento de datos y la reutilizacin de cdigo, mediante el
acceso por mtodos y los mecanismos de herencia.
Con el desarrollo del paradigma lgico, se pretendi simplificar la construccin de
programas que requieren implementar algoritmos para bsqueda de objetivos, permitiendo
representar el problema mediante la definicin de un conjunto de reglas lgicas, que son evaluadas
por un motor de inferencia que est interconstruido en el sistema.
Por qu se desarroll el paradigma funcional? Acaso el imperativo-OO y el lgico no eran
suficientes? Para responder estas preguntas, debemos tener en cuenta que el modelo de
programacin funcional es bastante antiguo. Efectivamente, en el ao 1958 un grupo del MIT
liderado por el investigador John McCarthy, desarroll los conceptos fundamentales de la
programacin funcional, los cuales se materializaron en el diseo el lenguaje LISP (list processor o
procesador de listas). Esto es muy significativo, ya que debemos tener en cuenta que en ese
momento, las computadoras eran las denominadas de la primera generacin y mayormente se
utilizaban para resolver problemas de tipo numrico, por lo que el desarrollo de un lenguaje capaz
de realizar procesamiento de tipo simblico, resulta todo un acontecimiento.
De todas formas cabe preguntarse para qu se desarrollaron los otros paradigmas. La
respuesta parte de las mismas consideraciones que hicimos en los prrafos anteriores, ya que si bien
LISP es muy adecuado para resolver determinado tipo de problemas, no lo es para otros, y por eso
surgieron otros modelos de programacin. Desde entonces ha sido un lenguaje muy usado en el
desarrollo de programas en el rea de inteligencia artificial. En este ltimo campo de aplicaciones,
recin con la aparicin de PROLOG, el lenguaje LISP tuvo un competidor con la suficiente
aceptacin, como para ser considerado una buena alternativa.

El lenguaje LISP tiene una sintaxis muy particular que a muchos no les satisface, pero que
sin embargo le permite ofrecer una uniformidad sintctica, que facilita el tratamiento de los
programas como si fueran datos. Adems no necesitan que se definan tipos de datos lo cual
simplifica la programacin, y si bien esto tiene los problemas que ya conocemos, permite construir
prototipos rpidamente. En realidad el problema del almacenamiento de datos en memoria es
completamente transparente para el usuario del lenguaje.
Adems, la programacin funcional pretende asegurar la coherencia sintctica en la
construccin de programas, y a partir del formalismo matemtico minimizar los errores de
evaluacin. Esto se debe a que se sustenta en el trabajo desarrollado por Alonzo Church en la
dcada del 30, denominado clculo lambda. Este fue propuesto como un modelo terico de
computacin, en forma similar a como Alan Turing propuso las mquinas de Turing (hay que tener
en cuenta que en esa poca an no exista una computadora electrnica!)
A partir de Lisp, derivaron otros lenguajes funcionales como Scheme y ML, el cual dio
origen a una rama de lenguajes funcionales entre los cuales se ubica Haskell. Este ltimo, es un
lenguaje funcional puro, de propsito general, que incluye muchas de las ltimas innovaciones en el
desarrollo de lenguajes, adems de incorporar conceptos como funciones de orden superior,
evaluacin tarda (mecanismo semejante al comportamiento del pasaje de argumentos por nombre
estudiado en SSL), tipos polimrficos, tipos definidos por el usuario, listas por comprensin,
entrada/salida funcional, etc.
2.1. Programacin funcional con Haskell
En el paradigma funcional, caracterizamos un problema por medio de la definicin de una
funcin que lo represente. Esta funcin podemos definirla por extensin o bien por compresin.
Uno de los principios de este modelo expresa que el valor de una expresin depende slo de sus
subexpresiones. Con esto quedan excluidos los efectos laterales en las expresiones, debidos al
proceso de asignacin. Por lo tanto en un programa funcional, se garantiza que una expresin tenga
el mismo valor cada vez que se evala.
As como la base terica de la programacin imperativa se debe a Alan Turing (Inglaterra)
en los aos treinta, la base terica del modelo funcional, tambin proviene de esa dcada. Algunos
de los principales fundadores del modelo son M. Schnfinkel (Alemania), Alonzo Church (Estados
Unidos) y Haskell Curry (Inglaterra). Una de la formas de notacin de funciones en Haskell que
se ver ms adelante se debe a este ltimo por lo que se la suele denominar currificada.
Ejemplo de un esquema funcional puede ser el siguiente: F(x) = 10 x + 5, donde x es el
argumento nominal de la funcin, que denota un valor vlido dentro del dominio de la funcin. A la
derecha del smbolo igual se encuentra una expresin, que caracteriza a la imagen de la funcin que
se define. En esta expresin aparecen los smbolos + y , los cuales representan a las funciones
suma y producto respectivamente. De esta forma se est indicando que para obtener la imagen de x
en F, deben aplicarse las funciones suma y producto a ciertos valores. Entonces sera vlido decir
que la funcin F(x), es construida a partir de la aplicacin de otras funciones. De este modo
tenemos un conjunto de funciones, que responden a una organizacin jerrquica anidada, las que en
conjunto dan solucin al problema.
As en este paradigma la solucin de un problema, debe expresarse mediante un conjunto de
definiciones funcionales, cuya evaluacin permite construir los objetos que dan respuesta al

problema planteado. De este modo, podramos establecer un esquema de construccin de programas
nicamente basado en llamadas a funciones y el uso de recursin, sin emplear asignaciones o
construcciones iterativas.
El modelo funcional de Haskell, tiene como objetivo la utilizacin de funciones puras sin
efectos laterales y, por tanto, sin asignaciones destructivas. El esquema del modelo funcional es
similar al de una calculadora. Se establece una sesin interactiva entre sistema y usuario: el usuario
introduce una expresin inicial y el sistema la evala mediante un proceso de reduccin. En este
proceso se utilizan las definiciones de funcin realizadas por el programador hasta obtener un valor
no reducible.
El valor que devuelve una funcin, est determinado nicamente por el valor de sus
argumentos, consiguiendo que una misma expresin tenga siempre el mismo valor (esta propiedad
se conoce como transparencia referencial). De esta forma, es ms sencillo demostrar la correccin
de los programas ya que se cumplen propiedades matemticas tradicionales como la propiedad
commutativa, asociativa, etc.
El programador se encarga de definir un conjunto de funciones sin preocuparse de los
mtodos de evaluacin que posteriormente utilice el sistema. Este modelo da mayor libertad al
sistema de evaluacin, para incorporar pasos intermedios de transformacin de cdigo y
paralelizacin, ya que las funciones no tienen efectos laterales y no dependen de una arquitectura
concreta.
La importancia de la programacin funcional no radica nicamente en no utilizar
asignaciones destructivas. Este modelo promueve adems la utilizacin de una serie de
caractersticas como las funciones de orden superior, los sistemas de inferencia de tipos, el
polimorfismo, la evaluacin perezosa, etc.
2.2. Principales caractersticas del lenguaje Haskell
La sintaxis del lenguaje diferencia entre maysculas y minsculas.
2.2.1. Funciones orden superior
Un lenguaje utiliza funciones de orden superior cuando las funciones son tratadas como
datos. Esto es que permite que sean almacenadas en estructuras de datos, que sean pasadas como
argumentos de funciones y que sean devueltas como resultado.
La utilizacin de funciones de orden superior ofrece mayor flexibilidad, siendo una de las
caractersticas ms sorbresalientes de los lenguajes funcionales.
2.2.2. Sistemas de inferencia de tipos y polimorfismo
Un sistema de inferencia de tipos se caracteriza por:
1. No se est obligado a declarar el tipo de las expresiones
2. El compilador contiene un algoritmo que infiere el tipo de las expresiones

3. Si se declara el tipo de alguna expresin, el sistema chequea que el tipo declarado
coincide con el tipo inferido.
Los sistemas de inferencia de tipos permiten mayor seguridad, evitando errores de tipo en
tiempo de ejecucin y una mayor eficiencia, ya que se evita realizar comprobaciones de tipos en
tiempo de ejecucin.
Los sistemas de inferencia aplican el concepto de polimorfismo, por el cual la funcin se
independiza del tipo de dato con el que trabaje. Sea el caso de un lenguaje que no aplique el
concepto de polimorfismo, si hacemos una funcin que devuelva el mayor valor de un par que se le
pasan como argumentos, como el algoritmo requiere hacer una comparacin, se necesitara hacer
una funcin para cuando los valores son enteros o reales, otra para cadenas de caracteres y otras
para cada par de objetos de datos de tipos no compatibles.
2.2.3. Pasaje de argumentos por nombre
Los lenguajes tradicionales, evalan todos los argumentos (parmetros reales) de una
funcin al llamarla, en cambio en los lenguajes funcionales los argumentos slo se evalan, si el
parmetro formal asociado en la definicin de la funcin se utiliza, en caso contrario no calculan la
expresin asociada en el argumento de llamada. Por ejemplo en JS, dado que los argumentos se
pasan por valor, el siguiente programa entrara en un bucle infinito.
<script language="JavaScript">
function algo(j){
while (j > 0) alert(j++);
}

function otra(x, y){
return x + 3;
}

function mia(){
return otra(2, algo(3));
}
</script>
Si bien es un ejemplo trivial, ilustra una situacin en la cual se puede caer, durante el
desarrollo de un programa complejo. En un lenguaje funcional, como el parmetro formal y no se
utiliza en la funcin otra(), el parmetro real asociado en la llamada nunca se evala y no cae en un
ciclo infinito.
2.2.4. Valores como abstracciones
En general a un valor abstracto le pueden corresponder diferentes representaciones. Por
ejemplo a la expresin 7 * 7 le corresponden: cuadrado 7, 49, 31 (en hexadecimal), 110001 (en
binario) ya que representan el mismo valor.
El proceso de evaluacin consiste en tomar una expresin y transformarla aplicando las
definiciones de funciones hasta que no pueda transformarse ms. La expresin resultante se
denomina representacin cannica y es el resultado del proceso de evaluacin.

2.2.5. Sintaxis
Haskell utiliza un sistema separador de enunciados bidimensional denominado layout, que
supone que las declaraciones estn alineadas por columnas. Por ejemplo:
l et y = a * b
f x = ( x + y) / y
i n f c + f d
Observe que tanto y como f comienzan en la misma columna, por lo tanto forman parte de la
misma definicin. Se deben respetar dos reglas:
1. El caracter que sigue a una de las palabras reservadas where, let, o of, determina la
columna de comienzo desde donde deben escribirse las declaraciones locales
correspondientes a where, let o case en las lneas subsiguiente.
2. La columna de comienzo debe aparecer ms a la derecha que la correspondiente a la
declaracin actual, por lo que el final de una declaracin se detecta cuando aparece algo
a la izquierda de la columna de comienzo asociada.
Identificadores de funciones
El nombre de una funcin puede ser un identificador (por ejemplo, sum, product y fact) o un
smbolo de operacin (por ejemplo, * y +). El sistema distingue entre los dos tipos segn la forma
en que estn escritos:
1. Un identificador comienza con una letra del alfabeto seguida, opcionalmente, por una
secuencia de caracteres, cada uno de los cuales es, una letra, un dgito, un apstrofe (') o
un subrayado (_).
2. Los identificadores que representan funciones o variables deben comenzar por letra
minscula (los identificadores que comienzan con letra mayscula se interpretan como
funciones constructoras).
Palabras reservadas
case of where let in if then else data type
infix infixl infixr primitive class instance
Smbolos
Los siguientes smbolos se usan como operadores, ya sean solos o combinados.
\ ^ | - : ! # $ % & * + . / < =
> ? > @
El carcter (~) se permite en la primera posicin del nombre.

Los nombres de operador que comienzan con (:) se utilizan para funciones constructoras
como los identificadores que comienzan por mayscula mencionados anteriormente.
Los siguientes smbolos tienen usos especiales:
= .. @ :: \ | <- -> ~ =>
Todos smbolos de operador se pueden utilizar como nombres de variables o funciones:
==> $ @@ -*- \/ /\ ... ?>
+ ++ && || <= == /= // .
Para usar un identificador como un smbolo de operacin o a la inversa:
1. Cualquier identificador ser tratado como un smbolo de operacin si est encerrado
entre comillas inversas (`). As, cualquier expresin de la forma "x `id` y" es
equivalente a "id x y"
2. Cualquier smbolo de operacin puede ser tratado como un identificador
encerrndolo entre parntesis. Por ejemplo, "x + y" podra escribirse como "(+) x y".
Las reglas de precedencia y asociatividad de operadores, son las habitualmente aplicadas en
los lenguajes de programacin basados en notacin infija. Por defecto, todo smbolo de operacin
se toma como no-asociativo y con precedencia mxima (va de 0 a 9), sin embargo puede alterarse
mediante una declaracin de la siguiente forma: <calificador> [dgito] <lista> donde:
<calificador> puede ser infixl, infixr, infix, e indican asociatividad a izq., dcha. o ninguna.
<dgito> es un valor entre 0 y 9, e indica la jerarqua de precedencia (si se omite es 9).
<lista> es el conjunto de smbolos que se redefinen.
Expresiones if
if <expr e- bool > then <expr e> else <expr e>
Ejemplo:
par i dad x = if ( x mod 2) == 0 then " par " else " i mpar "
Expresiones case
case <expr e> of { <expr e> -> <expr e> }+
Ejemplo:
par i dad x = case ( x mod 2) of
0 -> " par "
1 -> " i mpar "

2.3. Operadores y funciones
El mdulo de biblioteca bsica de Haskell se denomina standar prelude. El mismo incluye
un amplio conjunto de operadores y funciones que manipulan por ejemplo enteros:
+ suma.
* multiplicacin.
- substraccin.
^ potenciacin.
negat e menos unario (la expresin "- x" se toma como "negat e x")
di v divisin entera
rem resto de la divisin entera.
mod mdulo, como r emslo que el resultado tiene el mismo signo que el divisor.
odd devuelve True si el argumento es impar
even devuelve True si el argumento es par.
gcd mximo comn divisor.
l cm mnimo comn mltiplo.
abs valor absoluto
si gnum devuelve - 1, 0 o 1 si el argumento es negativo, cero o positivo,
respectivamente.
Incluye tambin funciones de manipulacin de flotantes: pi , exp, l og, sqr t , si n,
cos, t an, asi n, acos, at an, etc.
2.3.1. Operadores lgicos
En general presentan caractersticas similares a los del lenguaje C, pero se incorpora el
tipo de dato lgico, y proporciona las constantes lgicas true y false. A continuacin se muestran
algunos ejemplos de uso.
Hugs> 1 < 2 => True
Hugs> 2 < 1 => False
Hugs> 2 + 3 > 1 + 4 => False
Hugs> 5 /= 1 + 4 => False uso del operador distinto
Pueden ser combinados con los operadores && || not:
Hugs> 1 < 2 && 3 < 4 => True
Hugs> 1 == 1 || 2 == 3 => True
Hugs> not (1 < 2) => False
2.4. Tipos de datos
El sistema de tipos estticos de Haskell aporta los beneficios ya vistos en el curso de SSL,
asegurando que un programa sea type safe; asegurando que no se puedan evaluar expresiones con
tipos errneos. As el sistema asegura que los tipos que el usuario proporciona para las funciones

son correctos, en caso de no indicarse el tipo aplica inferencia de tipos. Algunas de las
caractersticas son:
1. no se est obligado a declarar el tipo de las expresiones.
2. el compilador contiene un algoritmo que infiere el tipo de las expresiones.
3. si se declara el tipo de alguna expresin, el sistema chequea que el tipo declarado coincida
con el tipo inferido.
Ejemplos de valores y sus tipos (donde :: significa es del tipo):
5 : : I nt eger val or at mi co
' a' : : Char val or at mi co
f unc : : I nt eger - > I nt eger una f unci n cual qui er a, por ej empl o de ent er os
sobr e ent er os
[ 1, 2, 3] : : [ I nt eger ] l i st a de ent er os
( ' b' , 4) : : ( Char , I nt eger ) par f or mado por un car ct er y un ent er o
2.4.1. Cadenas
Una cadena se trata como una lista de caracteres, as el tipo String equivale a "[Char]". Las
cadenas pueden indicarse encerradas entre comillas dobles, siendo vlido usar los cdigos de
escape utilizados para los caracteres.
Hugs> "hola" => hola
Hugs> "Hola, " ++ "amigo" => Hola, amigo
Hugs> concat ["12","34","56","78"] => 12345678
2.5. Intrprete Haskell
El ambiente WinHUGS establece un entorno interactivo a travs de un intrprete. Una vez
iniciado, el sistema muestra un prompt "Hugs>" (esto puede cambiar en otro ambiente), y se queda
esperando que se introduzca una expresin y se presione la tecla <RETURN>. Luego el sistema
evala la expresin e imprime su valor antes de volver a mostrar el prompt para esperar a que se
introduzca la siguiente expresin. Ejemplos:
Hugs> (2 + 3) * 8 40
Hugs> sum [1..10] 55 suma los elementos de las lista desde 1 hasta 10
La notacin [1..10] representa la lista de enteros que van de 1 hasta 10, y sum es una funcin
estndar que devuelve la suma de una lista de enteros.
2.6. Funciones
Una de las formas de definicin de una funcin responde a la siguiente sintaxis:

<nombre> ( [<var>] {, <var>}) = <expresin>
As, podemos definir la funcin de suma de dos valores como:
suma( x, y) = x + y
Otra forma de hacerlo por lo general la ms frecuente es la que se denomina parcializada
(o currificada, donde especificamos el prototipo de la funcin y luego definicin:
<nombre> :: { <tipo> -> } <tipo>
<nombre> { <var> } = <expresin>
Por ejemplo la definicin de la funcin suma sera:
suma : : I nt eger - > I nt eger - > I nt eger
suma x y = x + y
Lo que estamos expresando es que suma es una funcin que aplica en y el resultado se
aplica en . Veamos que esta aplicacin es equivalente a ( suma e
1
) e
2
, ya que la aplicacin de
funciones es asociativa a la izquierda. En otras palabras, al aplicar suma a un argumento se obtiene
una nueva funcin que puede ser aplicada al segundo argumento. Esto es consistente con el tipo de
suma, I nt eger - >I nt eger - >I nt eger , ya que es equivalente a I nt eger - >( I nt eger - >I nt eger ) ,
dado que - > es asociativo a derecha.
Por ejemplo ahora podemos definir i nc como:
i nc = add 1
Estamos haciendo una aplicacin parcial de una funcin parcializada, lo que constituye un
ejemplo de cmo podemos devolver una funcin como un valor.
2.6.1. Definiciones locales
Las definiciones de funcin podran incluir definiciones locales para variables que ponen
con guardas o en la parte derecha de una ecuacin.
Veamos la siguiente funcin que calcula el nmero de races de una ecuacin cuadrtica de
la forma ax
2
+ bx + c = 0
ecuacRai ces a b c
| di scr > 0 = 2
| di scr == 0 = 1
| di scr < 0 = 0
wher e di scr = b * b 4 * a * c
Las definiciones locales pueden tambin introducirse en cualquier lugar de una expresin
utilizando la forma:

let <decl s> in <expr >
Por ejemplo:
Hugs> l et x = 1 + 4 i n x * x + 3 * x + 1 => 41
Otro uso de where, por ejemplo para definir la funcin derivada, donde su prototipo expresa
que recibe como argumento una funcin de reales sobre reales, y regresa una funcin de la misma
forma. Aqu observe el uso del ; para separar ms de una definicin en el where.
di f f : : ( Fl oat - >Fl oat ) - > ( Fl oat - >Fl oat )
di f f f = f dev
wher e { f dev x = ( f ( x + h) - f x) / h; h = 0. 0001 }
2.6.2. Re-definicin de un operador
Supongamos que necesitamos definir un operador de valor aproximado (en un mdulo
llamado mio.hs), de modo tal que en lugar de hacer comparaciones por igualdad (x == y), podamos
hacer x ~= y, cuyo significado sera el valor de x es prximo al de y.
i nf i x 5 ~= - - est abl ecemos que ser un oper ador i nf i j o con pr i or i dad 5
a ~= b = a - b < h && b - a < h - - def i ni mos cmo se cal cul a l a oper aci n
wher e h = 0. 000001 - - f i j amos el mar gen de apr oxi maci n
Ahora podramos preguntar por ejemplo:
Mi o> 1. 01 ~= 1. 001 => Fal se
Mi o> 1. 00000001 ~= 1. 0000000011 => Tr ue
2.6.3. Definicin por patrones
A continuacin se muestra la sintaxis de declaracin, donde <patrn> representa los
argumentos de la funcin. Si f fuese definida por ms de una ecuacin, entonces stas deben
definirse juntas y cada una debe tener la misma aridad: func { <patrn> } = <expresin>
Sea la siguiente funcin f1 que realiza el producto de valores, y tiene los parmetros
formales x, y:
f 1 x y = x * y
En una llamada a la funcin, se le pasan los parmetros actuales:
f1 17 (1 + g) donde 17 es el parmetro actual que corresponde a x, (1 + g) es el parmetro
actual que corresponde a y. Es importante recordar que el mecanismo de pasaje de argumentos es el
denominado por nombre (estudiado en el curso SSL). El resultado es 17 * (1 + g), o sea que los
parmetros actuales son expresiones y los formales son nombres.
Esto no siempre es as en Haskell, ya que un parmetro formal puede ser tambin un patrn.
Un ejemplo de la definicin de una funcin en que se usa un patrn como parmetro formal sera:

f 2 2 z = 2 + z
Esta funcin slo se puede llamar con el primer argumento 2 y el segundo cualquier valor o
expresin.
Veamos la definicin de la funcin potencia usando patrones:
x ^ 0 = 1
x ^ ( n + 1) = x * x ^ n
Una definicin recursiva en que se usan patrones para distinguir diferentes casos (en lugar
de expresiones lgicas) se llama tambin definicin inductiva.
Comparacin de patrones con expresiones case
Para el caso de de tener que "transferir el control" basndose en las propiedades
estructurales de un valor.
f unc p
11
. . . p
1k
= expr e
1

. . .
f unc p
n1
. . . p
nk
= expr e
n

Se puede re-escribir as:
f unc x
1
x
2
. . . x
k
= case ( x1, . . . , xk) of
( p
11
, . . . , p
1k
) -> expr e
1

. . .
( p
n1
, . . . , p
nk
) -> expr e
n
2.6.4. Definicin por recursin o induccin
En la definicin de una funcin se pueden usar funciones estndar y funciones definidas por
el usuario, o tambin se puede usar la forma recursiva. Veamos el caso tpico del factorial:
f ac n
| n == 0 = 1
| n > 0 = n * f ac ( n - 1)
2.6.5. Abstraciones lambda
Tambin es posible definir funciones en forma "annima" va una abstracin lambda. Por
ejemplo, podemos escribir una funcin equivalente a i nc en la forma \ x - > x + 1.
Del mismo modo, la funcin add es equivalente a \ x - > \ y - > x + y. Las lambda
abstracciones pueden anidarse de la siguiente otra forma equivalente \ x y - > x + y.
La sintaxis general es : \ { <patrn atmico> }+ -> <expresin>
As por ejemplo, la expresin: (\x -> x * x) representa la funcin que toma un nico
argumento entero 'x' y produce el cuadrado de ese nmero como resultado.

2.6.6. Funciones no estrictas
Sea una definida en la forma: una = una, es un ejemplo de una expresin funcional que no
termina.
Una funcin f se dice estricta si, al ser aplicada a una expresin sin terminacin, tampoco
termina. En otras palabras, f es estricta si el valor de f es una expresin que no termina. En la
mayora de los lenguajes de programacin todas las funciones son estrictas, pero no es as en
Haskell. Por ejemplo consideremos const 1, la funcin constante igual a 1:
const 1 x = 1
As el valor de const 1 una es 1. Operacionalmente hablando, ya que const 1 no "necesita"
el valor de su argumento, el sistema nunca intentar evaluarlo, y no se produce un cmputo sin
terminacin. Aqu se aplica un concepto similar al pasaje de parmetros por nombre visto en SSL.
Las funciones no estrictas suelen llamarse "perezosas", y sus argumentos son evaluados slo
cuando es necesario.
Las funciones no estrictas son muy tiles, dado que liberan al programador de algunas
consideraciones sobre el orden de evaluacin. Podemos pasar valores que contienen gran cantidad
de clculos como argumentos sin preocuparnos de los cmputos que necesitan realizarse. Un
ejemplo de esto son las estructuras de datos infinitas que se vern al presentar el concepto de lista.
Otra caracterstica de las funciones no estrictas, es que los cmputos de Haskell se describen
a travs de definiciones, al contrario de las asignaciones que se hacen en los lenguajes
tradicionales.
2.6.7. Iteraciones
El mdulo de biblioteca estndar de Haskell (standard prelude) nos provee de una forma de
iteracin a travs de la funcin until. La funcin se define con 3 parmetros:
1. una funcin de algn tipo sobre booleanos, que indica cmo deber ser el resultado
final.
2. otra funcin de un tipo sobre el mismo tipo, que se aplica en cada iteracin.
3. un valor de algn tipo, que indica cul es el valor inicial para la iteracin.
La funcin regresa un valor de algn tipo. Observe que con a se indica valores de
cualquier tipo, pero todos del mismo. La definicin es la siguiente:
unt i l : : ( a- >Bool ) - > ( a- >a) - > a - > a
unt i l p f x - - condi ci n, f unci n a apl i car , val or i ni ci al
| p x = x - - si el val or i ni ci al cumpl e l a condi ci n, t er mi na y
devuel ve ese val or
| ot her wi se = unt i l p f ( f x) - - si no i t er a r ecur si vament e, apl i cando f
al val or x
Por ejemplo si damos como condicin de finalizacin que el valor de control debe ser mayor

de 1000, como funcin a aplicar el producto de 2 por el valor de control, y 1 como valor inicial para
el control, el lazo iterara 1, 2, 4, 8, 16, 32 hasta 1024:
Hugs> unt i l ( >1000) ( 2 *) 1 => 1024
Veamos un ejemplo de aplicacin. Sea el problema de evaluar el cero de una funcin (o sea
donde se anula). En un curso de Mtodo Numricos se estudia algoritmos que permiten resolver
este tipo de problemas. Para eso inicialmente se supone un punto b como cero de la funcin, si lo
es, ya se solucion el problema, pero sino podemos ver en la grfica que la interseccin de la
tangente a f en b con el eje x, es una mejor aproximacin.
Podemos ver que el punto de interseccin que buscamos est a una distancia d de la primera
aproximacin b. Entonces podemos calcular el valor de d como d = f(b) / f(b), donde la pendiente
de la tangente (o sea la derivada) a f en el punto b es igual a f(b).

Luego a partir de lo anterior podemos obtener una mejor aproximacin con b f(b) / f(b), a
esto se le denomina Mtodo de Newton. Entonces la funcin donde se ha elegido como primera
aproximacin el valor 1.0 (pudo ser cualquier otro), quedara as:
punt oCer o : : ( Fl oat - > Fl oat ) - > Fl oat
punt oCer o f = unt i l acept abl e mej or ar 1. 0
wher e { mej or ar b = b - f b / di f f f b; acept abl e b = f b ~= 0. 0 }
Luego por ejemplo:
Mi o> punt oCer o cos => 1. 570796
Mi o> punt oCer o si n => 0. 0
2.7. Definicin de mdulos
Para los ejemplos antes vistos, se utilizaron funciones predefinidas, incluidas en un archivo
denominado "estndar prelude" que es cargado al arrancar el sistema. Adems se pueden definir
nuevas funciones y guardarlas en un archivo, de forma que el sistema pueda utilizarlas
posteriormente.
Por ejemplo, el usuario podra crear un archivo archivo.hs con las siguientes definiciones:

Cuadr ado : : I nt eger - > I nt eger
cuadr ado x = x * x

menor : : ( I nt eger , I nt eger ) - > I nt eger

menor ( x, y) = i f x <= y t hen x el se y
-- Cabecera de funcin que
recibe y regresa un entero

-- Cabecera de funcin que
recibe dos argumentos enteros
y regresa un entero
- - Enunciado condicional
Para poder utilizar las definiciones anteriores, es necesario cargar las definiciones del
archivo en el sistema. La forma ms simple consiste en utilizar el comando ":load":
Hugs> :load archivo.hs
Si el archivo se carga correctamente, entonces se puede pedir que se evale:
Hugs> cuadr ado ( 3+4) 49
Como vemos las funciones desarrolladas por el usuario deben estar definidas en un archivo
con la extensin .hs, y cargarlo a memoria para poder utilizarlas. Veamos un ejemplo de la
estructura de un archivo con cdigo Haskell.
module Mio ( El nombre del encabezado mdulo debe ser igual al del archivo.
factorial, fibonacci Entre parntesis se listan los nombres de las funciones del mdulo.
) where palabra reservada
-- factorial Los comentarios se preceden con - -
factorial :: Integer -> Integer Funcin que recibe un argumento entero y devuelve un entero
factorial 0 = 1 Axioma del factorial
factorial n = n * factorial (n - 1) Definicin por recurrencia del factorial
-- fibonacci
fibonacci :: Integer -> Integer
fibonacci n Definicin utilizando un enunciado condicional mltiple, donde cada
| n < 0 = -1 guarda indicada con el operador | restringe una opcin, esto
| n == 0 = 0 opera como un enunciado condicional mltiple
| n == 1 = 1
| n > 1 = fibonacci (n - 1) + fibonacci (n - 2)
? Se puede omitir el encabezado del mdulo. Qu pasa si se omite la lista entre parntesis.

2.8. Tipos estructurados
2.8.1. Listas
Las listas son conjuntos de elementos del mismo tipo. As, existen listas de enteros, listas de
flotantes, listas de funciones de entero a entero, etc. Tambin se pueden agrupar en una lista listas
del mismo tipo.
El tipo de una lista se indica escribiendo el tipo de sus elementos entre corchetes. Por ejemplo
listas de:
enteros: [Int]
flotantes: [Float]
enteros sobre flotantes: [Int->Float]
listas de booleanos: [[[Bool]]]
Operadores de lista
head devuelve la cabeza de la lista, head [1,2,3,4,5] => 1
tail devuelve la cola de la lista, tail [1,2,3,4,5] => [2,3,4,5]
2.8.2. Construccin de listas
Por enumeracin
Es la forma ms bsica de construir una lista, donde describimos uno a uno los elementos que
integran una lista. Por supuesto esto slo es prctico para conjuntos pequeos.
[5] :: [Int] lista unitaria de enteros (singleton-list)
[1, 2, 3] :: [Int] lista de enteros
[True, False, True] :: [Bool] lista de booleanos
[sin, cos, tan] :: [Float->Float] lista de funciones de float sobre float
[ [1,2,3], [1,2] ] :: [[Int]] lista de listas de enteros
Los elementos no tienen que ser constantes, pueden ser expresiones de cualquier tipo, pero
deben ser todas del mismo tipos para cada lista:
[ 1 + 2, 3 * x, length [1,2] ] :: [Int] lista de expresiones enteras
[ 3 < 4, a == 5, p && q ] :: [Bool] lista de expresiones lgicas
[ diff sin, inverse cos ] :: [Float->Float]
[] :: [Int] lista vaca de enteros (las listas vacas son polimrficas)
sum [] [] es una lista vaca de nmeros
and [] [] es una lista vaca de booleanos
length [] [] es una lista vaca (no importa de que)
Constructor de listas :
Este operador agrega un elemento al principio (cabeza) de la lista (:) :: a -> [a] -> [a]

Por ejemplo si mia es la lista [3,4,5], entonces 1 : mia => [1,3,4,5]
Otro ejemplo a partir de la lista vaca, 1:(2:(3:[])) => [1,2,3]
El operador : es asociativo a derecha, por ello tambin se puede escribir as 1:2:3:[]
2.8.3. Funciones sobre listas
Veamos algunos ejemplos de aplicaciones de funciones sobre listas. Por ejemplo, veamos
dos formas de definir la funcin de suma de elementos de una lista.
Forma recursiva:
suma l i st a
| l i st a == [ ] = 0 si es l a l i st a vac a l a suma es 0 ( cer o)
| ot her wi se = head l i st a + suma ( t ai l l i st a)
si no suma l a cabeza de l a l i st a a l a col a
Forma inductiva (usando patrones):
suma [ ] = 0
suma ( cabeza : col a) = cabeza + suma col a
Definamos la funcin longitud, que calcula el nmero de elementos de una lista, en forma
inductiva:
l ongi t ud [ ] = 0
l ongi t ud ( cabeza: col a) = 1 + l ongi t ud col a
En la definicin por patrones se puede usar el smbolo _ (semejante a la variable annima
de Prolog):
l ongi t ud [ ] = 0
l ongi t ud ( _: col a) = 1 + l ongi t ud col a
Consideremos ahora el caso en el que pasamos una funcin como argumento. La funcin
predefinida map, tiene 2 argumentos, el primero es una funcin y el segundo es una lista, y lo que
hace map es aplicar la funcin argumento a cada elemento de la lista. Por ejemplo, si aplicamos la
funcin seno a la siguiente lista:
map sin [2, 3, 4] => [0.9092974268256, 0.1411200080598, -0.7568024953079]
Donde la definicin de map es:
map : : ( a- >b) - > [ a] - > [ b]
Esto significa que map es una funcin, que recibe como primer argumento una funcin que
aplica un tipo a sobre un tipo b, como segundo argumento una lista de tipo a, y devuelve una
lista de tipo b.

map f [ ] = [ ]
Aqu se define que la aplicacin de f sobre la lista vaca, da la lista vaca.
map f ( x1: y1) = f x1 : map f y1
Finalmente, se define que map aplica f sobre la lista descripta por comprensin que est
formada por elementos de x1 a y1, construyendo una nueva lista que resulta de aplicar f a x1 ms la
aplicacin recursiva de map con f sobre y1, lo cual sera equivalente a (f x1) : (map f y1).
Un ejemplo de uso sera:
map ( add 1) [ 1, 2, 3] => [ 2, 3, 4]
Ejemplos de funciones de funciones sobre listas
map f ac [ 1, 2, 3, 4, 5] => [ 1, 2, 6, 24, 120] - - apl i ca f act or i al a cada
el ement o de l a l i st a
map sqr t [ 1. 0, 2. 0, 3. 0, 4. 0] => [ 1. 0, 1. 41421, 1. 73205, 2. 0]
Uso de zip
zi p [ 1, 2, 3] " abc" => [ ( 1, ' a' ) , ( 2, ' b' ) , ( 3, ' c' ) ]
Ejemplos de definicin de funciones con patrones
suma [ ] = 0
suma [ x] = x
suma [ x, y] = x + y
suma [ x, y, z] = x + y + z
El caso de la funcin que determina la longitud de una lista, es un ejemplo de polimrfismo,
dado que es necesario que determine la longitud de cualquier lista, no importa el tipo de sus
elementos.
l ongi t ud : : Eq a => [ a] - > I nt eger
l ongi t ud l l
| l l == [ ] = 0
| ot her wi se = 1 + l ongi t ud ( t ai l l l )
? Qu funcin cumple la declaracin [a]
2.8.4. Arreglos
La funcin de creacin de un arreglo (tambin llamados tablas) se hace a partir de un par de
lmites y una lista de pares conteniendo ndices y valores (lista asociativa). Para esto se usa la
funcin constructora array, cuya forma general es:
ar r ay : : ( I x a) => ( a, a) - > [ ( a, b) ] - > Ar r ay a b
Esto sera array es una funcin de ndices (Ix es una librera de ndices predefinida en

Haskell), cuyos argumentos son un par de valores del tipo a, y una lista de pares de valores de tipo
a (el subndice) y b (el valor asociado), que devuelve un objeto Array (un conjunto de subndices
del tipo a y valores del tipo b).
Por ejemplo para crear una tabla con los cuadrados de los nmeros del 1 al 100:
xx = ar r ay ( 1, 10) [ ( i , i + 2) | i <- [ 1. . 10] ]
Asocia a xx un arreglo de 10 pares de elementos, conteniendo cada uno de ellos el valor del
subndice e inicializado con el resultado de sumarle 2 al subndice correspondiente, y cuya forma
sera: array (1, 10) [ (1, 3), (2, 4), (3, 5), (4, 6), (5, 7), (6, 8), (7, 9), (8, 10), (9, 11), (10, 12) ]
El acceso a un elemento de la tabla se realiza a travs del operador !, y los lmites pueden
averiguarse con la funcin bounds:
squar es! 3 => 5
bounds squar es => ( 1, 10)
Podemos definir tablas recursivamente, por ejemplo la siguiente funcin devuelve una tabla
con los nmeros de Fibonacci:
f i bo : : I nt - > Ar r ay I nt I nt
f i bo n = a wher e a = ar r ay ( 0, n) ( [ ( 0, 1) , ( 1, 1) ] ++
[ ( i , a! ( i - 2) + a! ( i - 1) ) | i <- [ 2. . n] ] )
La operacin range toma un par de lmites y produce la lista de los ndices que
comprendidos entre esos lmites, en el orden del ndice. Por ejemplo:
r ange ( 0, 4) => [ 0, 1, 2, 3, 4]
r ange ( ( 0, 0) , ( 1, 2) ) => [ ( 0, 0) , ( 0, 1) , ( 0, 2) , ( 1, 0) , ( 1, 1) , ( 1, 2) ]
Existe una operacin inRange que determina si un ndice est entre un par de lmites dados.
Los elementos se numeran desde cero, pero como hemos visto podemos definir el rango de
valores que toman los subndices. La operacin index se usa para acceder a un elemento
determinado del array dado el par de lmites y un ndice dentro del rango, la operacin devuelve el
ordinal del ndice (empieza en cero) partiendo del origen dentro del rango, por ejemplo:
i ndex ( 1, 9) 2 => 1 - - ser a el el ement o 1 del conj unt o
[ 0, 1, 2, 3, 4]
i ndex ( ( 0, 0) , ( 1, 2) ) ( 1, 1) => 4 - - ser a el el ement o 4 del conj unt o
[ ( 0, 0) , ( 0, 1) , ( 0, 2) , ( 1, 0) , ( 1, 1) , ( 1, 2) ]
? Cmo sera la definicin de un arreglo de enteros de 3 dimensiones.
2.8.5. Estructuras de datos infinitas
Hemos visto el concepto de funcin no estricta, los constructores son una forma de funcin,
por lo tanto tambin pueden ser no estrictos, lo cual permite definir estructuras de datos infinitas.
Por ejemplo la siguiente definicin, establece una lista infinita de unos:
uno = 1 : uno

La definicin anterior, el lenguaje la implementa con una lista circular, con objeto de
economizar espacio de memoria.
Otro caso es la lista infinita de valores a partir de n:
val or es n = n : val or es ( n + 1)
Entonces si probamos: valores 5, comenzarn a generarse los valores [5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, hasta que detengamos la ejecucin
(Men Actions, Stop).
Tambin podemos aplicarle la funcin cuadrado y nos permitira construir la lista infinita de
cuadrados:
cuadr ados = map ( ^2) ( val or es 0)
Existen funciones predefinidas en Haskell para operar con listas, por ejemplo t ake extrae
los primeros elementos de una lista (en este caso 5):
take 5 cuadr ados => [ 0, 1, 4, 9, 16]
Otro caso es takeWhile, que nos permite por ejemplo tomar los elementos menores de 1000:
takeWhile ( < 1000) ( map ( 3 ^) [ 1. . 10] )
[ 3, 9, 27, 81, 243, 729]
2.9. Tuplas
Se usan para agrupar elementos del mismo o de diferentes tipos, a fin de tratarlos como un
solo concepto. Por ejemplo, la informacin en un registro de personas puede contener un nombre
(cadena), el sexo (por ejemplo booleano) y la edad (entero). Las tuplas se denotan con parntesis y
sus elementos separados por comas.
Ejemplos
("daniel", True, 23) tupla con tres elementos
(1, a) tupla con los elementos 1 (entero) y a (caracter)
([1, 2], sqrt) tupla con dos elementos: una lista de enteros y una funcin
(1, (2, 3)) tupla con dos elementos: un nmero y una tupla
2.10. Tipos definidos por el usuario
2.10.1. Sinnimos de tipo
Es algo semejante al uso que se hace de typedef en C, ya que permite crear un sinnimo
para referirse a un tipo de dato. Su forma sintctica ms simple es:
type <nombre> = <expresion_tipo> donde

nombre: es el nombre de un nuevo tipo y expresion_tipo: es una expresin que denota el tipo
Ejemplos
type String = [Char]
type Nombre = String
type Edad = Integer
type Persona = (Nombre, Edad)
A continuacin definimos el tipo Punto, formado por dos valores flotantes, que representan
los valores de ordenada y abscisa en el plano cartesiano.
type Punto = (Float, Float)
Luego una funcin que calcula la distancia entre dos puntos (a, b), sera:
distancia :: Punto -> Punto -> Float
distancia (ax, ay) (bx, by) = sqrt ((abs (ax bx)) ^ 2 + (abs (ay by)) ^ 2)
2.10.2. Definicin de tipos compuestos
Para definir nuevos tipos de datos, se utiliza el enunciado data. Por ejemplo definamos un
tipo compuesto para manejar informacin de empleados, relativa al nombre y sueldo. As Empleado
sera el nombre del tipo, formado por el tipo compuesto Datos, que est integrado por un String y
un Float, donde su significado sera el nombre y sueldo respectivamente.
data Empleado = Datos String Float
Luego declaramos la variable juan del tipo Empleado:
juan :: Empleado
A continuacin asignamos valores:
juan = Datos "Juan Perez" 3534.56
Ahora definimos una funcin que utiliza el tipo de dato que hemos definido y que devuelve
el valor de sueldo:
gana :: Empleado -> Float
gana (Datos x y) = y
Finalmente preguntamos:
Hugs> gana juan => 3534.56

2.10.3. Definicin mediante campos con nombre
Aqu tambin utilizamos el enunciado data. Veamos como sera para el caso anterior:
data Empleado = Datos { nombre::String, sueldo::Float }
juan, ana :: Empleado
Asignamos valores:
juan = Datos {nombre = "Juan Perez", sueldo = 3534.56}
ana = Datos {nombre = "Ana Gomez", sueldo = 2564.60}
Luego definimos una funcin que regresa un descuento (11%) aplicado sobre el sueldo de
un empleado (el uso de la variable indeterminada slo ilustrativo, ya que no resulta imprescindible
aplicar este concepto):
descuento :: Empleado -> Float
descuento (Datos _ sueldo) = sueldo * 0.11
Finalmente preguntamos:
Hugs> descuento ana => 282.106
? Se pueden anidar las definiciones de tipos compuestos. Cmo se hara.
2.11. rboles
La definicin de un rbol sera un caso de aplicacin de data, a fin de crear un nuevo tipo.
Por ejemplo la creacin del rbol que muestra la
figura, en el que la informacin se ubica en los nodos
intermedios, sera como se muestra a continuacin.

Describimos el rbol en forma recursiva, como formado por una Hoja, o un Nodo que tiene
asociado un valor de algn tipo (a) y dos subrboles.
data Mi Ar bol a = Nodo a ( Mi Ar bol a) ( Mi Ar bol a) | Hoj a

Asociamos a la variable mio la definicin del rbol en particular que nos interesa. Observe
que la estructura de patentizado sigue la estructura descripta con data para el rbol.

mi o = Nodo 4 ( Nodo 2 ( Nodo 1 Hoj a Hoj a) ( Nodo 3 Hoj a Hoj a) )
( Nodo 6 ( Nodo 5 Hoj a Hoj a) ( Nodo 7 Hoj a Hoj a) )
Luego definimos por ejemplo una funcin que calcula la cantidad de nodos del rbol.
cant i dad : : Mi Ar bol a - > I nt
cant i dad Hoj a = 0
cant i dad ( Nodo x p q) = 1 + cant i dad p + cant i dad q

Veamos ahora el caso de un rbol cuya informacin est en las hojas y no en los nodos.
data Ar bol a = Rama ( Ar bol a) ( Ar bol a) | Hoj a a
Luego creamos un rbol en particular, asociado a la variable a1.
a1 = Rama ( Rama ( Hoj a 45) ( Hoj a 78) )
( Rama ( Hoj a 12) ( Rama ( Hoj a 23) ( Hoj a 13) ) )
Finalmente la funcin para evaluar su tamao sera:
cant i dad : : Ar bol a - > I nt
cant i dad ( Hoj a x) = 1
cant i dad ( Rama x y) = cant i dad x + cant i dad y
? Cmo sera el dibujo que corresponde al grafo que representa este ltimo rbol.


P Pa ar ra ad di ig gm ma a O Or ri ie en nt ta ad do o a a O Ob bj je et to os s
3. PROGRAMACIN ORIENTADA A OBJETOS
3.1. El paradigma imperativo
Dentro de este modelo de programacin, la evolucin tuvo lugar desde los primeros
lenguajes en los cuales los programas se desarrollaban en forma lineal. Pasando luego por diversas
etapas hasta llegar a la construccin estructurada y la basada en tipos abstractos de datos. A partir
de las cuales evolucionaron las tcnicas orientadas a objetos.
Entonces dentro de este paradigma podemos efectuar dos clases de abordajes para la
resolucin de problemas.
Descomposicin algortmica
Bajo este punto de vista, el problema es descompuesto progresivamente en subproblemas
independientes que participan del modelo en tratamiento. Cada uno de los subproblemas se resuelve
independientemente y se conectan entre s, a travs de interfaces. En este enfoque cada
subproblema se materializa en algn tipo de rutina (por lo general parametrizada), ya sea una
funcin o procedimiento. Este tipo de desarrollo est basado en la comunicacin, a travs de las
interfaces de las rutinas.
La aplicacin de este enfoque, fuerza una estructura de diseo jerrquica (top-down), e
implica una fuerte relacin entre la descripcin esttica de los algoritmos y su dinmica de
comportamiento, esto lleva a que muchas veces cualquier modificacin en el comportamiento del
modelo dinmico, obliga a modificar parte del cdigo existente en muchos puntos.
Descomposicin en objetos
Bajo este enfoque, el problema es descompuesto progresivamente en las abstracciones, que
aparecen en el mismo (empleado, auto, avin, comprador, etc.). Esto significa que son identificadas
las entidades que participan del problema y su comportamiento. Luego, cada abstraccin se
materializa en algn tipo de objeto, dentro del cual son encapsulados los atributos y
comportamientos del mismo, por medio de un conjunto de variables y mtodos (funciones y/o
procedimientos). Las abstracciones se describen en forma genrica a travs del concepto de clase,
luego a partir de estas se crean los objetos, que se comunican entre s a travs de mensajes.
En la prctica, tanto el enfoque algortmico como el orientado a objetos, son importantes. El
primero pone nfasis en el orden de los eventos que tienen lugar en el sistema. El segundo, en los
agentes que provocan dichos eventos.
El modelo orientado a objetos permite una modelizacin cercana a la realidad, ya que resulta
ms natural identificar los objetos que participan de un problema, sus atributos y
comportamientos, para luego representarlos bajo un modelo de software.
3.2. Construccin de programas O.O.
Veamos una definicin de lo que es la programacin orientada a objetos, que hace G. Booch
en su libro Diseo y Programacin Orientada a Objetos: Es un mtodo de implementacin en el

cual los programas son organizados como colecciones cooperativas de objetos, cada uno de los
cuales representa una instancia de alguna clase, y todas las clases son miembros de una jerarqua
unida bajo la va de relaciones de herencia.
Cuando construimos un programa, fundamentalmente lo que hacemos es construir un
modelo que simula la realidad. Por supuesto que esa representacin no es completa, ya que hemos
eliminado todos aquellos detalles no relevantes para nuestros objetivos, por eso hablamos de una
abstraccin.
La abstraccin es uno de los medios fundamentales por el cual las personas, enfrentamos la
complejidad de los problemas. La abstraccin podemos verla como la simplificacin de la
descripcin de un sistema. En la misma, hacemos caso omiso de los detalles del mismo, para as
concentrarnos en los aspectos relevantes. El problema, es justamente definir claramente que es
relevante y que no.
Es esta una de las tareas crticas en el desarrollo de un sistema, y en buena medida se
relaciona con la experiencia del analista, ya que si bien, las metodologas nos ayudan por medio de
diversas tcnicas a modelar el problema, es en la primera etapa en la cual definimos el dominio del
problema y sus lmites, y de la cual depende el resto.
La abstraccin que se haga de un problema depende del observador y de los objetivos que se
persiguen. De hecho, dos personas distintas pueden obtener abstracciones completamente
diferentes, de un mismo sistema. Consideremos como ejemplo a una persona como un objeto y
veamos, las distintas percepciones que pueden existir segn el observador.
OBSERVADOR ABSTRACCION QUE HACE (de una persona)
Poltico votante
DGI contribuyente
Mdico paciente
Luego, en cada caso, las propiedades del objeto que interesarn son distintas, si bien hay
algunas que sern comunes a todos.
3.2.1. Nombres en las diferentes metodologas O.O.
UML Clase Asociacin Generalizacin Agregacin
Booch Clase Usos Herencia Contener
Coad Clase y Objeto Conexin de Instancia Gen-Spec Todo-Parte
Jacobson Objeto Asociacin Conocida Herencia Consta de
Odell Tipo de Objeto Relacin Subtipo Composicin
Rumbaugh Clase Asociacin Generalizacin Agregacin
Shlaer/Mellor Objeto Relacin Subtipo N/A

3.3. Tipos estructurados y abstractos
En los lenguajes tradicionales como C, Pascal, entre otros, existen tipos de datos
primitivos como son los enteros, reales, etc., pero tambin es posible definir nuevos tipos de datos
estructurados. Por ejemplo en C, hemos visto en el curso de Sintaxis y Semntica de Lenguajes
(SSL), que podemos definir un tipo de dato PERSONA, que contenga como miembros de datos el
Nombre, la FechaNacimiento, DNI, etc. Luego una variable de ese tipo nos permite almacenar toda
esta informacin relacionada con una persona.
Entonces podemos declarar una variable de ese tipo, del mismo modo que lo hacemos con
una variable entera. La diferencia est en que mientras una variable entera, representa en el
contexto de nuestro programa a un objeto simple, que almacena un nmero; en el caso de la
variable de tipo PERSONA, la misma en un objeto complejo, que almacena varios datos
relacionados con una persona. Un lenguaje que soporte tipos de datos abstractos, nos permitira
definir adems de lo anterior, algunas funciones relacionadas con las personas, como calcular su
edad a partir de la fecha de nacimiento. En resumen un tipo de dato abstracto, es aquel que
encapsula no slo datos, sino adems funciones/procedimientos relacionados con esos datos.
3.4. Lenguajes orientados a objetos
Dentro de esta categora podemos mencionar lenguajes como SmallTalk, Eiffel, Java, C++,
ObjectPascal; donde los dos ltimos son del tipo hbrido, ya que no soportan el paradigma en
forma pura, en tanto Java respecta la mayor parte de las carctersticas del paradigma. Esto es,
que bajo estos dos lenguajes uno construye un programa respetando la metodologa O.O. porque
quiere, y no porque el procesador del lenguaje obligue a ello.
Un lenguaje orientado a objetos es aquel que nos permite implementar en forma natural las
caractersticas del paradigma.
El que un lenguaje soporte un paradigma, involucra adems de las ya enunciadas, algunas
sutilezas ms, como el hecho de efectuar determinadas verificaciones en tiempo de compilacin o
de ejecucin, de las reglas que se deben respetar bajo el modelo.
Si bien cada lenguaje tiene caractersticas particulares, algunos de los aspectos
fundamentales que permiten implementar los lenguajes O.O., son:
1. Definicin de clases.
1. Especificacin de jerarquas de clases.
2. Creacin de objetos simples o complejos.
3. Especificacin de una estructura lgica de programa, basada en el intercambio de
mensajes entre objetos.
3.4.1. Lenguaje Java
Sun Microsystems es la empresa responsable del desarrollo del lenguaje Java. Lo que
motiv su desarrollo fue el intentar resolver los problemas que se planteaban al desarrollar
software, debido a la proliferacin de arquitecturas incompatibles de hardware y S.O.

Uno de los proyectos de Sun, era desarrollar software para control de equipos domsticos:
microondas, tostadoras y fundamentalmente, televisin interactiva. Este mercado, dada la falta de
pericia de los usuarios para el manejo de estos dispositivos, requera interfaces mucho ms cmodas
e intuitivas que los sistemas de ventanas que proliferaban en ese momento.
Uno de los aspectos ms importantes a tener en cuenta en este proyecto, era la confiabilidad
del cdigo y la facilidad de desarrollo. James Gosling un miembro del equipo, con gran experiencia
en lenguajes de programacin, decidi que las ventajas aportadas por la eficiencia de C++ no
compensaban el gran coste de pruebas y depuracin.
En los lenguajes como C o C++, los programas deben compilarse para una arquitectura, pero
si esta cambia, todo el software debe compilarse de nuevo. Esto encarece mucho los desarrollos.
Por tanto, Gosling decidi mejorar las caractersticas de un lenguaje que estaba desarrollando,
denominado Oak.
El desarrollo de varios proyectos basados en estas ideas, no tuvieron xito por diversos
motivos. Pero uno de los fundadores de Sun (Bill Joy), que tambin haba trabajado en el proyecto
Unix de Berkeley, pens que Internet era un rea donde disputar a Microsoft su liderazgo casi
absoluto en software, y crey que Oak poda ser el instrumento adecuado. Tras un cambio de
nombre y modificaciones de diseo, el lenguaje Java fue presentado en agosto de 1995.
Comencemos por describir algunos conceptos fundamentales que es necesario dominar para
poder desarrollar programas O.O.
? Qu es la VM de Java.
3.4.2. Paquetes
El concepto de mdulo visto en SSL, en Java est implementado a travs de paquetes. Un
paquete es un contenedor de clases y actan como libreras. Un paquete se organiza agrupando los
archivos Java (.class), en un directorio (supongamos \progs\mios). El cdigo fuente a partir del cual
se compilaron esos archivos, debe encabezarse con:
package progs.mios;
Luego para importar el paquete completo se indica:
import progs.mios.*;
Si queremos importar uno slo de los archivos del paquete (por ejemplo arreglos.java),
debemos indicar:
import progs.mios.arreglos;
Algunos paquetes de Java que vienen con el JDK bsico son:
java.lang: Este paquete incluye las clases para poder trabajar con Java como: Object,
Thread, Exception, System, Integer, Float, Math, Package, String, etc.. No es necesario importar
nada desde este paquete, ya que se carga por defecto.

java.util: Este paquete incluye muchas clases tiles como pueda ser Date (fecha) y diversas
clases que permiten el almacenamiento dinmico de informacin, como Vector, LinkedList,
HashMap, etc.
java.applet: Contiene la clase Applet, que nos permite crear applets para correrlos con un
navegador.
java.awt: Este paquete (Abstract Windowing Toolkit) contiene las clases necesarias para
crear interfaces de usuario, por medio de mens, botones, reas de texto, cajas de confirmacin, etc.
java.io: Este paquete contiene las clases necesarias para realizar las operaciones de
entrada/salida, ya sea a pantalla o a ficheros, clases como FileInputStream y FileOutputStream, etc.
java.net: Paquete que permite la programacin de aplicaciones que accedan a bajo nivel a
redes TCP/IP.
? Cmo se generan los archivos .class y qu es lo que contienen.
3.4.3. Tipos primitivos y clases equivalentes
Tipo Descripcin Tamao Clase equivalente
boolean Valor lgico 1 bit Boolean
char Carcter 16 bits Character
byte Entero muy pequeo 8 bits
short Entero pequeo 16 bits
int Entero normal 32 bits Integer
long Entero grande 64 bits Long
float Nmero real de precisin simple 32 bits Float
double Nmero real de doble precisin 64 bits Double
void Sin informacin de tipo
? Por qu se dice que Java es multiplataforma.
3.4.4. Operadores
La jerarqua y asociatividad de los operadores es similar a la vista en SSL para C.
operadores sufijo
[ ] . ( ) var ++ var - -
operadores unarios
++var - - var +var var ~ !
creacin y molde (cast)
new ( t i po) expr esi n
multiplicadores
* / %
suma/resta
+ -

desplazamiento
<< >> >>>
relacionales
< > <= >= i nst anceof
igualdad
== ! =
bitwise AND
&
bitwise exclusive OR
^
bitwise inclusive OR
|
AND lgico
&&
OR lgico
| |
Condicional
? :
Asignacin
= += - = *= / = %= ^= &= | = <<= >>= >>>=
? Qu es un archivo .jar.
3.4.5. Sintaxis del lenguaje
A continuacin se enuncian las reglas sintcticas en BNF (segn lo visto en SSL).
Modulo ::= [ DeclaracionDeModulo ] <DeclaracionDeImportacion>
<DeclaracionDeTipo> .

DeclaracionDeModulo ::= package NombreDelModulo ; .

DeclaracionDeImportacion ::= import ( ( NombreDelModulo . * ; )
| ( NombreDeLaClase | NombreDeLaInterface ) ) ; .

DeclaracionDeTipo ::= [ TextoDeComentario ] ( DeclaracionDeClase | DeclaracionDeInterface ) ;.

TextoDeComentario ::= (/* ... texto ... */) | (// ... texto ...) .

DeclaracionDeClase ::= <modificador> class identificador [ extends NombreDeLaClase ]
[ implements NombreDeLaInterface < , NombreDeLaInterface> ]
{ <DeclaracionDeCampo> } .

DeclaracionDeInterface ::= <modificador> interface identificador
[ extends NombreDeLaInterface <, NombreDeLaInterface> ]
{ <DeclaracionDeCampo> } .

DeclaracionDeCampo ::= ( [ TextoDeComentario ] ( DeclaracionDeMetodo
| DeclaracionDeConstructor | DeclaracionDeVariable ) )
| InicializadorEstatico | ; .

DeclaracionDeMetodo ::= <modificador> tipo identificador ( [ ListaDeParametros ] )
< [ ] > ( BloqueDeSentencias | ; ) .

DeclaracionDeConstructor ::= <modificador> identificador ( [ListaDeParametros] )
BloqueDeSentencias .

BloqueDeSentencias ::= { <Sentencia> } .

DeclaracionDeVariable ::= <modificador> tipo DeclaracionDeVariable < , DeclaracionDeVariable > ; .

DeclaracionDeVariable ::= identificador < [ ] > [= InicializadorDeVariable] .


InicializadorDeVariable ::= expresion | ( { [InicializadorDeVariable
< , InicializadorDeVariable > [ , ] ] } ) .

InicializadorEstatico ::= static BloqueDeSentencias .

ListaDeParametros ::= parametro < , parametro > .

parametro ::= tipo identificador < [ ] > .

Sentencia ::= DeclaracionDeVariable
| ( expresion ; )
| ( BloqueDeSentencias )
| ( SentenciaIf )
| ( SentenciaDo )
| ( SentenciaWhile )
| ( SentenciaFor )
| ( SentenciaTry )
| ( SentenciaSwitch )
| ( synchronized ( expresion ) Sentencia )
| ( return [expresion] ; )
| ( throw expresion ; )
| ( identificador : Sentencia )
| ( break [identificador] ; )
| ( continue [identificador] ; )
| ( ; ) .

SentenciaIf ::= if ( expresion ) Sentencia [ else Sentencia ] .

SentenciaDo ::= do Sentencia while ( expresion ) ; .

SentenciaWhile ::= while ( expresion ) Sentencia .

SentenciaFor ::= for ( (DeclaracionDeVariable | ( expresion ; ) | ;)
[expresion] ; [expresion] ; ) Sentencia .

SentenciaTry ::= try Sentencia < catch ( parametro ) Sentencia>
[ finally Sentencia ] .

SentenciaSwitch ::= switch ( expresion ) { < ( case expresion : )
| ( default : )
| Sentencia> } .

expresion ::= ExpresionNumerica
| ExpresionDeTest
| ExpresionLogica
| ExpresionCadena
| ExpresionDeBit
| ExpresionDeConversion
| CreacionDeExpresion
| ExpresionLiteral
| null
| super
| this
| identificador
| ( ( expresion ) )
| ( expresion ( ( ( [ ListaDeArgs ] ) )
| ( [ expresion ] )
| ( . expresion )
| ( , expresion )
| ( instanceof ( NombreDeLaClase
| NombreDeLaInterface) ) ) ).

ExpresionNumerica ::= ( ( - | ++ | -- ) expresion ) | ( expresion ( ++ | -- ) )
| ( expresion ( + | += | - | -= | * | *= | |

| |= | % | %= ) expresion ) .

ExpresionDeTest ::= ( expresion ( > | < | >= | <= | == | != ) expresion ).

ExpresionLogica ::= ( ! expresion ) | ( expresion ( & | &= | | | |= | ^ | ^=
| ( & & ) | ||= | % | %= ) expresion )
| ( expresion ? expresion : expresion )
| true | false .

ExpresionCadena ::= ( expresion ( + | += ) expresion ) .

ExpresionDeBit ::= ( ~ expresion ) | ( expresion ( >>= | << | >> | >>> ) expresion ) .

ExpresionDeConversion ::= ( tipo ) expresion .

CreacionDeExpresion ::= new ( ( NombreDeClase ( [ListaDeArgs] ) )
| ( EspecificadorDeTipo [ [ expresion ] ] < [ ] > )
| ( ( expresion ) ) ) .

ExpresionLiteral ::= LiteralEntero | LiteralFloat | Cadena | Caracter .

ListaDeArgs ::= expresion < , expresion > .

tipo ::= EspecificadorDeTipo < [ ] > .

EspecificadorDeTipo ::= boolean | byte | char | short | int | float
| long | double | NombreDeLaClase | NombreDeLaInterface .

modificador ::= public | private | protected | static | final
| native | synchronized | abstract | threadsafe | transient .

NombreDelModulo ::= identificador | ( NombreDelModulo . identificador ) .

NombreDeLaClase ::= identificador | ( NombreDelModulo . identificador ) .

NombreDeLaInterface ::= identificador | (NombreDelModulo . identificador) .

LiteralEntero ::= ( ( 1..9 < 0..9 > ) | < 0..7 > | ( 0 x 0..9a..f < 0..9a..f > ) ) [ l ] .

LiteralFloat ::= ( DigitosDecimales . [ DigitosDecimales ] [ Exponente ]
[ SubfijoTipoFloat ] )
| ( . DigitosDecimales [ Exponente ] [ SubfijoTipoFloat ] )
| ( DigitosDecimales [ Exponente ] [ SubfijoTipoFloat ] ) .

DigitosDecimales ::= 0..9 < 0..9 > .

Exponente ::= e [ + | - ] DigitosDecimales .

SubfijoTipoFloat ::= f | d .

caracter ::= conjunto de caracteres de la tabla Unicode .

string ::= <caracter> .

identificador ::= a..z, $, _ <a..z, $, _, 0..9, caracteres Unicode mayores a 00C0> .

? A qu se refiere el trmino JIT.

3.5. Objetos
Un objeto representa un tem, unidad o entidad perfectamente identificable, ya sea real o
abstracto, con un rol bien definido en el dominio de un problema. Las principales caractersticas de
un objeto de dato podemos resumirlas en:
1. Estado
Involucra a todas las propiedades (en general estticas) del objeto de dato, adems de los
valores (en general dinmicos) actuales de cada una de esas propiedades del objeto. El estado queda
determinado por el valor de sus atributos y en el lenguaje de programacin, se implementa por
medio de variables.
2. Comportamiento
Es la descripcin acerca de como acta y reacciona un objeto, en trminos de cambios de
estado e intercambio de mensajes, o sea que el comportamiento de un objeto est definido por sus
acciones y en el lenguaje de programacin, se implementa por medio de funciones.
3. Identidad
Es la propiedad que hace que un objeto se distinga de cualquier otro del mismo tipo, no debe
confundirse con el concepto de nombre que se le asigna a un objeto para identificarlo como
abstraccin dentro del sistema. En un lenguaje de programacin, esto podramos asociarlo con la
direccin de memoria que ocupa.
Ejemplos de objetos pueden ser:
cosas tangibles como un auto, un avin, un libro, un reactor nuclear, una alarma (el
dispositivo).
roles que cumplen personas u organizaciones como un cliente, un empleado, un abogado, un
departamento, un empleador, un vendedor.
ocurrencias o eventos en el tiempo como un accidente, un llamado, un vuelo, la parada de un
sistema, una alarma (el hecho que suene).
las interacciones que relacionan con otros objetos una compra, una venta, un casamiento.
las especificaciones de otros objetos como el modelo de un auto, un tipo de seguro, etc.
? Qu define el estado de un objeto.

3.5.1. Descripcin de los objetos
La descripcin de un objeto, es aquella informacin relativa al mismo, que nos permite
afirmar con certidumbre, que una cosa del mundo real o no, es una instancia del tipo de objeto en
cuestin o no, de acuerdo a la conceptualizacin del mismo dentro del modelo de informacin.
Generalmente en un sistema complejo, la descripcin que hacemos de los objetos, pasa por definir

claramente las condiciones y caractersticas que debe reunir para ser una instancia.
Por ejemplo, en un sistema para el registro de la patente automotor, el vehculo debe tener
una antigedad menor de 30 aos, para ser incluido en la nmina de unidades que estn obligadas a
pagar. En este caso, si bien un auto puede tener todas las caractersticas de los objetos auto, para
este sistema en particular no podr ser considerado como tal.
Otro punto importante a describir de los objetos, es su relacin con otros, sobre todo cuando
es requisito para que exista dentro del sistema, que otro objeto tambin exista.
La descripcin de las caractersticas generales de los objetos se realiza a travs de la
definicin de clases.
3.5.2. Definicin de clases
Especificar una clase, es similar a definir un nuevo tipo de dato, en particular un tipo
abstracto de datos. Para la especificacin usaremos la palabra reservada class. Una clase puede
estar formada por cualquier combinacin de componentes privados, pblicos o protegidos.
Bsicamente especificar una clase, es similar a definir un nuevo tipo de dato, en particular
un tipo abstracto de datos. Para la especificacin usaremos la palabra reservada class. Una clase
puede estar formada por cualquier combinacin de componentes privados, pblicos o protegidos. Si
no se especifica nada, se asumen como privados.
Las variables de instancia y mtodos de una clase, son calificados segn las siguientes
categoras, las cuales determinan el acceso que se pueden tener a cada miembro de la clase en un
programa Java:
public: los miembros son visibles para la propia clase y al resto de ellas.
private: los miembros slo son visibles para la propia clase.
protected: los miembros son visibles para la propia clase, las subclases de esta y las clases que
pertenecen al mismo paquete.
private protected: los miembros son visibles slo para la propia clase y las subclases de esta.
friendly: valor por defecto si no se indica nada, equivale a protected.
? En qu se diferencian los conceptos de clase y objeto.
3.5.3. Atributos
Las caractersticas de los atributos podemos resumirlas en:
1. Un atributo es una caracterstica que poseen todos los objetos de un determinado tipo.
2. Los atributos son aquellos datos que permiten especificar la descripcin completa de un objeto.
3. Un atributo puede ser una referencia a otro objeto.

4. Los atributos permiten describir el estado de un objeto.
Supongamos que estamos caracterizando los objetos del tipo auto, con una lista de atributos
que ayudan a describir a un auto en particular: el color, el modelo, el tipo de motor, etc.
Los atributos que interesan a un sistema en particular, no necesariamente sern los mismos
para otro. Por ejemplo, el atributo, nmero de patente es necesario para un sistema de recaudacin
de impuestos, pero no lo es para un sistema de stock en fbrica.
Cuando describimos los atributos de un objeto, algunos de los aspectos que se indican son:
el nombre por el cual lo referimos, el tipo de valor al que se refiere, el rango de valores que puede
tomar, y cualquier otro aspecto que ayude a la descripcin del mismo. Podemos clasificar los
atributos de un objeto como de:
1. Instancia: en que cada objeto tiene su propia copia del atributo.
2. Clase: es nico y todos los objetos de una clase lo comparten.
3.5.4. Mtodos
Describen los distintos comportamientos que tiene un objeto, frente a la recepcin de
estmulos externos al mismo. En general las responsabilidades de un objeto, son implementadas a
travs de los mtodos. Los mtodos, son bsicamente rutinas para procesar determinados mensajes,
que un objeto reconoce.
Los mtodos podemos clasificarlos segn sus caractersticas en:
1. Internos: son funciones de uso interno de la clase, pero no puede ser ejecutados en forma directa
mediante el envo de mensajes externos.
2. Instancia: Son aquellos que reflejan las responsabilidades asignadas a los objetos de una clase.
3. Clase: Son aquellos que reflejan las responsabilidades asignadas a la clase en s, por ejemplo la
creacin de objetos.
3.5.5. Mensajes y mtodos
Una vez definida una clase pueden definirse objetos de esa clase y activar sus mtodos. Un
programa O.O. Se basa en el intercambio de mensajes entre objetos que pertenecen a alguna clase.
Un objeto slo puede reaccionar ante mensajes para los cuales tenga definidos mtodos especficos.
La forma genrica de enviar un mensaje es la siguiente: Id-objeto.id-mtodo(argumentos) donde
el punto indica que id-mtodo es un miembro del objeto id-objeto.
3.6. Objetos de un programa
Un programa O.O. trabaja en base a un conjunto de objetos, que encapsulan las propiedades
y comportamientos del sistema que se ha modelado. Estos objetos son creados a partir de
definiciones previas y durante la ejecucin de la aplicacin intercambian mensajes entre s.
Al recibir un mensaje un objeto cualquiera, se activa el mtodo correspondiente. Como
resultado de esto un objeto puede cambiar su estado o no, enviar un mensaje a otro objeto, devolver

un valor, y/o cualquier otra accin, segn lo especificado en la implementacin del mtodo.
Un objeto responde a los mensajes que se le envan, usando los mtodos que figuran en la
descripcin de su clase.
El estado de un objeto es almacenado en las
llamadas variables de instancia, la especificacin de
estas figura en la descripcin de la clase a la que
pertenece el objeto es cuestin.
El nombre de un mtodo est asociado a la
clase en que se define, por esto otra clase puede tener
un mtodo con el mismo nombre y cuando se active
un mtodo de un objeto, se ejecutar el que
corresponde a la clase a la que pertenece el objeto.
? Es obligatorio definir constructores en cada clase.
3.7. Constructores y destructores de objetos
Cuando en un lenguaje tradicional, declaramos una variable de algn tipo primitivo, al
ejecutarse dicha sentencia, son realizadas diversas tareas relacionadas con su creacin, como la
reserva de espacio e inicializacin (si corresponde). Por lo general para la creacin y destruccin de
cualquier objeto, se deben realizar una serie de tareas, estas ltimas son indicadas en mtodos
especiales, que son los constructores y el destructores de la clase.
Las variables de instancia de los objetos de una clase slo pueden ser inicializadas por el
constructor al crearse los objetos en tiempo de ejecucin. Estos mtodos son llamados en forma
automtica para crear o destruir objetos.
Al definir un constructor se le debe dar el mismo nombre que a la clase
Una clase puede tener definidos varios constructores (a esto se le denomina sobrecarga),
para diferentes situaciones de uso de la misma, por ejemplo el constructor de copia de objetos de la
clase, que es usado para crear duplicados de los objetos de una clase.
Los constructores, en realidad son mtodos de la clase, ya que no son ejecutados para una
instancia de objeto en particular, sino justamente para crearlo. No devuelven ningn valor y no se
debe indicar nada como tipo de devolucin, ni siquiera la palabra void.
La inicializacin de las variables de instancia de un objeto, se hace al declararlas en la clase
o por medio del constructor.
? Cuntas formas de pasaje de parmetros tiene Java.
Instancia de un objeto auto:

ATRIBUTOS:
Patente =AXT342
Propietario ="P. Garca"
Marca ="Ford"
MTODOS: MENSAJ ES:
pagarImpuesto pagarImpuesto
elDueo elDueo
cualEsLaMarca cualEsLaMarca


3.8. Sobrecarga de mtodos
Una clase puede tener funciones (mtodos), con el mismo nombre e implementaciones
diferentes, pero que deben poder diferenciarse por la lista de parmetros, ya sea por la cantidad de
parmetros o el tipo. Esto es lo que se denomina sobrecarga (ver SSL). En cada situacin de uso, la
funcin a ejecutar es asociada de acuerdo al prototipo que se adapta a la llamada.
EJEMPLO
i mpor t j ava. i o. *;
cl ass Numer oRaci onal {
pr i vat e l ong numer ador ; / / se i ni ci al i zan en 0 por def ect o
pr i vat e l ong denomi nador ;
publ i c Numer oRaci onal ( l ong n, l ong d) {
numer ador = n > 0 ? n : 0; / / se r est r i nge a posi t i vos
denomi nador = d > 0 ? d : 0;
}
publ i c Numer oRaci onal ( ) { / / const r uct or sobr ecar gado
numer ador = 0;
denomi nador = 0;
}
publ i c Numer oRaci onal ( Numer oRaci onal obj ) { / / const r uct or sobr ecar gado de copi a
numer ador = obj . numer ador ;
denomi nador = obj . denomi nador ;
}
publ i c voi d asi gnar ( l ong n, l ong d) {
numer ador = n > 0 ? n : 0; / / se r est r i nge a posi t i vos
denomi nador = d > 0 ? d : 0;
}
publ i c voi d asi gnar ( Numer oRaci onal obj ) { / / EN J AVA:
i f ( obj ! = t hi s) { / / par a evi t ar r easi gnar el mi smo obj et o
numer ador = obj . numer ador ; / / l os obj et os de t i po no pr i mi t i vo
denomi nador = obj . denomi nador ; / / si empr e se pasan por r ef er enci a
}
}
publ i c bool ean esI gual ( Numer oRaci onal obj ) { / / mt odo par a compar ar dos nmer os
r et ur n numer ador == obj . numer ador && denomi nador == obj . denomi nador ;
}
}
publ i c cl ass pr ueba {
publ i c st at i c voi d mai n( St r i ng [ ] ar g) {
Numer oRaci onal a, b, c, d;
a = new Numer oRaci onal ( ) ; / / EN J AVA:
b = new Numer oRaci onal ( 3, 4) ; / / l os obj et os de t i po no pr i mi t i vo
c = new Numer oRaci onal ( b) ; / / sl o pueden cr ear se en f or ma
d = new Numer oRaci onal ( b) ; / / di nmi ca
a. asi gnar ( b) ;
i f ( c. esI gual ( d) )

Syst em. out . pr i nt l n( I gual es) ;
el se
Syst em. out . pr i nt l n( Di st i nt os) ;
}
}
? Cmo se destruye explcitamente un objeto en Java.
Comentarios acerca del programa:
La variable this que se utiliza en la sentencia if ( obj != this), en una referencia (un puntero)
que pertenece al ambiente predefinido de referencia de Java. Siempre contiene la direccin de
memoria del objeto para el cual se ha activado el mtodo que se est ejecutando. En este caso se la
utiliza para verificar que la referencia al objeto obj no sea la misma que la del objeto activo, ya que
en ese caso se estara asignando el mismo objeto.
Si bien otros lenguajes O.O. permiten implementar mtodos destructores, para destruir los objetos
de datos creados en forma dinmcia, en Java no es necesario, ya que posee un mecanismo
automtico de destruccin.
3.9. Relaciones entre objetos
3.9.1. Notacin UML e implementacin en Java de relaciones
Modelo Descripcin Implementacin
Herencia o generalizacin:

Son las relaciones donde una
clase hereda propiedades de
otra.

class B extends A {
}
Asociacin:

Establecen alguna forma de
comunicacin entre dos clases.
Cuando hay multiplicidad,
pueden implementarse con
arreglos o usando contenedores.
cl ass A {
publ i c B ot or ga[ ] ;
}

cl ass B {
publ i c A pi de;
}


Asociacin unidireccional:

Similar a la anterior, pero
califica el sentido de la
comunicacin.
Uno a muchos
cl ass A {
}

cl ass B {
publ i c A cobr a[ ] ;
}

Agregacin:

Son una forma de asociacin y
se usan para representar la
situacin de que un objeto de
una clase est agregado dentro
de otro que pertenece a otra
clase:
Agregacin
- Uno o ms objetos estn
lgicamente contenidos dentro
de otro/s. El objeto agregado,
existe independientemente de
aquel que lo contiene.
Composicin
- Un objeto es fsicamente
construido a partir de otro. Esto
implica que al destruir el objeto
compuesto, tambin se
destruye el objeto interno.
Agregacin:
cl ass A {

}
cl ass B {
publ i c A cont eni do[ ] ;
}

Composicin:
cl ass A {
publ i c B i ncor por ar [ ] ;
}
cl ass B {
publ i c A cont eni do;
}

Dependencia o instanciacin:

Se da cuando un elemento del
modelo, depende de modo tal
que si el primero se modifica, el
segundo se ve afectado.
Por ejemplo si A: Stock y B:
OrdenDeCompra, una venta va a
implicar la modificacin del
estado de los objetos que
pertenecen a las dos clases.
Se trata de una relacin dinmica (no
es esttica).

B x = new A( ) ;
. . .
x. unMet odo( ) ;

Realizacin o implementacin:

Ocurre entre:
Class e Interface
Interface y Class
Component e Interface
Package e Interface
Package y Class
Indica que la primera
implementa una operacin u
propiedad definida en la
segunda.
i nt er f ace A {
voi d al macenar ( ) ;
}
cl ass B i mpl ement s A {
voi d al macenar ( ) {}
}

Clase asociativa:

Se trata de una clase que
describe una relacin de
asociacin entre otras dos clases.
Por ejemplo los objetos de la
clase D podran servir como
argumentos en la activacin de
mtodos, que implementan la
relacin esttica existente.
cl ass A {
publ i c B t heB;
}

cl ass B {
publ i c A gr aba[ ] ;
}

cl ass D {
}
? Por qu existen las clases Integer, Float, etc. si ya se cuenta con los tipos int, float, etc.
3.9.2. Herencia
Es la propiedad de heredar atributos y comportamientos de clases superiores en jerarqua,
llamadas superclases o clases bases, esta caracterstica permite aumentar el grado de reusabilidad de
los componentes del sistema.
En cada caso se debe analizar si lo que existe entre dos clases, es una relacin de herencia, o
una relacin de continencia de una dentro de otra. La primera suele darse cuando se puede
expresar que una clase "es un/a", la segunda habitualmente cuando se da la forma "tiene un/a".
Normalmente para poder entender la utilidad de una clase, es necesario estudiar sus superclases.
Una de las tareas ms difciles, es analizar y disear adecuadamente, la estructura de
relaciones y dependencias que existen entre las clases de un sistema, y un error grueso en esta
parte puede llevar a la inutilizacin de todo el desarrollo. Existen dos tipos de herencias, la simple y
la mltiple.
Herencia simple
Se da cuando una clase hereda propiedades, solamente de una nica clase de superior en

jerarqua. Los mecanismos de herencia, son los que permiten crear las jerarquas de clases
estructuradas en los denominados rboles de herencia, que a su vez hacen posible aplicar el
concepto de construccin incremental de software.
EJEMPLO
Se quieren modelar diversas figuras geomtricas. En el ejemplo, las clases, Circulo,
Irregular y Rectngulo, heredan los atributos propiedades (atributos) y los comportamientos
(mtodos) de la clase Figura; mientras que Triangulo y Trapecio heredan de Irregulares y por lo
tanto tambin de Figura en forma transitiva.
Cada figura es fabricada con el mismo tipo de material, el cual tiene un determinado precio
por centmetro cuadrado. El precio de una figura cualquiera se calcula multiplicando el valor del
precio por la superficie de la figura y por el espesor del material.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
abst r act cl ass Fi gur a {
pr ot ect ed f l oat espesor ;
publ i c st at i c f i nal f l oat pr eci o = 5. 35;
publ i c Fi gur a( f l oat e) {
espesor = e;
}
publ i c abst r act doubl e super f i ci e( ) ;
publ i c abst r act doubl e per i met r o( ) ;
publ i c f l oat cost o( ) { r et ur n super f i ci e( ) * pr eci o * espesor ; }
}
cl ass Rect angul o ext ends Fi gur a {
pr ot ect ed doubl e al t o, ancho;
publ i c Rect angul o( f l oat e, doubl e l , doubl e n) {
super ( e) ;
al t o = l ;
ancho = n;
}
publ i c doubl e super f i ci e( ) { r et ur n al t o * ancho; }
publ i c doubl e per i met r o( ) { r et ur n al t o * 2 + ancho * 2; }
}
abst r act cl ass I r r egul ar es ext ends Fi gur a {
pr ot ect ed doubl e al t u;
publ i c I r r egul ar es( f l oat e, doubl e h) {
super ( e) ;
al t u = h;
}
}
cl ass Tr i angul o ext ends I r r egul ar es {
pr i vat e doubl e hi pot ;
publ i c Tr i angul o( f l oat e, doubl e h, doubl e t ) {
super ( e, h) ;
hi pot = t ;
}
publ i c doubl e super f i ci e( ) {
r et ur n Mat h. sqr t ( hi pot * hi pot - al t u * al t u) ) * al t u / 2;
}
publ i c doubl e per i met r o( ) {
r et ur n al t u + hi pot + Mat h. sqr t ( hi pot * hi pot - al t u * al t u) ) ) ;
}
}
cl ass Tr apeci o ext ends I r r egul ar es {
pr i vat e doubl e bmayor , bmenor ;
publ i c Tr apeci o( f l oat e, doubl e h, doubl e m, doubl e n) {
super ( e, h) ;
bmayor = m;
bmenor = n;
}
publ i c doubl e super f i ci e( ) { r et ur n ( bmayor + bmenor ) * al t u * 2; }
publ i c doubl e per i met r o( ) { r et ur n 0; }
}
cl ass Ci r cul o ext ends Fi gur a {

52
53
54
55
56
57
58
59
60
pr i vat e f i nal doubl e PI = 3. 14;
pr ot ect ed doubl e r adi o;
publ i c Ci r cul o( f l oat e, doubl e r ) {
super ( e) ;
r adi o = r ;
}
publ i c doubl e super f i ci e( ) { r et ur n PI * r adi o; }
publ i c doubl e per i met r o( ) { r et ur n PI * r adi o * 2; }
}
Comentarios acerca del programa:
1: Que una clase sea abstracta implica que no pueden crearse objetos de la clase. Se usa cuando se
quieren representar conceptos que no tienen instancias. En este caso el concepto de Figura es una
generalizacin, que no tiene una instancia concreta a menos que se indique de que figura se trata.
2: Si se califica protected un miembro de la clase, slo es accesible desde esta y desde las subclases.
3: Calificar un atributo como static especifica que se trata de una variable de clase, hacerlo como
final especifica que se trata de una constante.
4: No es posible crear objetos de esta clase pero el constructor se usar para construir los subobjetos
que forman parte de los objetos que se creen de las clases derivadas.
7, 8: Si se califican abstract implica que no se implementan en la clase, pero que s se deben
implementar en las subclases, sino estas tambin pasan a ser abstractas.
11: El especificador extends indica la clase desde la cual se hereda.
14: La llamada al mtodo predefinido super, hace que se ejecute el constructor de la superclase.
Esta llamada debe ser la primera que aparezca en el constructor de una clase derivada de otra.
18, 19: Se implementan los mtodos abstractos de la superclase, a esto se le llama sobre-escritura de
mtodos (o redefinicin), no confundir con sobrecargar un mtodo dentro de una clase. En el caso
de la sobre-escritura de mtodos, los prototipos de ambos deben ser exactamente iguales.
29: Se califica privado, para que no se pueda acceder desde la subclase.
35: Aqu se utiliza el mtodo de clase sqrt(), perteneciente a la clase Math, para lo cual hay que
importar el package java.lang.Math
49: En este caso se ha supuesto que el modelo no requiere que se implemente este clculo. Por lo
tanto se ha realizado una implementacin trivial del mtodo, esto implica modelar un

comportamiento vaco, de modo que se cumple con el requisito de sobre-escribir el mtodo para
evitar que la subclase tambin sea abstracta, cuando se active esta funcin regresar el valor 0.
Supongamos que creamos la siguiente clase para probar el programa:
1
2
3
4
5
6
7
8
9
10
publ i c cl ass pr uebaFi gur as {
Fi gur a a;
a = new Rect angul o( 3. 5, 5. 0, 7. 0, 9. 0) ;
Syst em. out . pr i nt l n( a. super f i ci e( ) ) ;
a = nul l ;
a = new Ci r cul o( 6. 1, 3. 4, 12. 5) ;
Syst em. out . pr i nt l n( a. super f i ci e( ) ) ;
}
}
3: Si bien no pueden crearse objetos de la clase Figura es posible declarar variables de ese tipo. La
ventaja de esto es que con esas variables podemos referenciar objetos de cualquiera de las subclases
(siempre y cuando se puedan crear esos objetos).
4: Aqu se crea un objeto de la clase Rectangulo, que es referenciado con la variable a que es la
clase Figura, esto es vlido ya que el objeto creado no es de la clase Figura, sino de la Rectangulo.
Resumiendo podemos decir que con una variable del tipo de una superclase, es posible referenciar
objetos de cualquiera de las subclases de aquella.
5: Se activa el mtodo superficie() del objeto Rectangulo, ya que es el que referencia la variable a.
6: Esto anula la referencia al objeto Rectangulo y hace que quede disponible para su destruccin.
7: Ahora se crea un objeto de la clase Circulo. En este caso si en el paso anterior no se hubiera
asignado null, dara lo mismo ya que la referencia al objeto Rectangulo, igual se perdera, con lo
que quedara de todos modos disponible para su destruccin.
8: Se activa el mtodo superficie(), pero ahora el del objeto Circulo, ya que es el que en este
momento referencia la variable a.
La caracterstica de activar el mtodo que corresponde al objeto referenciado en un momento
dado, se denomina polimorfismo. Esto es lo que se describe en el modelo de objetos como la
propiedad de los objetos de reaccionar a un mensaje con el mtodo apropiado.
? Cul es la utilidad de this y super, usadas como referencias.
Herencia mltiple
Se da cuando una clase hereda en forma simultnea, propiedades de ms de una clase de
jerarqua superior. En este caso puede ocurrir que una subclase, herede dos mtodos con igual
nombre pero comportamientos diferentes por dos ramas distintas. En situaciones como estas, se
requiere especificar explcitamente la clase a la que pertenece el mtodo o variables de instancia,
que se desean acceder.
En el desarrollo de un programa O.O., aunque no es lo ms frecuente, a veces existe la

necesidad de describir jerarquas de herencia mltiple, como resultado de la identificacin de las
abstracciones y sus interrelaciones, que participan en el problema.
En Java la herencia mltiple est limitada, y slo es posible utilizando interfaces, que son clases
abstractas puras (todos los mtodos abstractos y todos los atributos constantes).
EJEMPLO
Si analizamos el diagrama que herencia de vehculos que se muestra ms abajo, veremos que
el esquema nos permite heredar atributos y comportamientos de ms de una clase superior. En este
caso por ejemplo un CAMION hereda de CARGA y esta de Vehculo, as podemos decir que un
CAMION es un Vehculo de CARGA.

? En qu se diferencian una interface de una clase abstracta.
3.9.3. Agregacin
Ocurre cuando una clase no hereda propiedades de otra, sino que, est incluida en otra. En
este caso una es la clase continente y la otra la contenida. Esta propiedad, como en la herencia,
permite rehusar clases para construir otras.
Las relaciones de agregacin normalmente se dan cuando se pueden expresar en trminos
"est formado por" o visto desde el otro lado forma parte de.
Podemos hablar de que un auto est compuesto por un motor? Si la respuesta es afirmativa,
entonces estamos en presencia de una relacin de agregacin. Las relaciones que implican un
vnculo ms fuerte, se las denomina de composicin. Por ejemplo:

a) un objeto MOTOR est formado por un CARBURADOR (agregacin)
b) un objeto CUERPO_HUMANO est compuesto por CEREBRO (composicin)
Por supuesto que no siempre las relaciones surgen en forma tan evidente. Normalmente esto
implica que se debe realizar un anlisis ms profundo del problema a modelar.
? Java soporta herencia mltiple.

3.9.4. Asociacin
Se da cuando un objeto de una clase est vinculado a un objeto de otra clase, de modo tal
que existe una relacin pero que no es de agregacin.
Por ejemplo en el modelo de un sistema de alumnos de la Facultad, entre un objeto
ALUMNO y un objeto EXAMEN (ya rendido), sera difcil hablar de que uno de ellos contiene al
otro, pero evidentemente existe un vnculo entre ambos (que podra expresarse como que un
ALUMNO RINDIO EXAMEN).
EJEMPLO
Implementar en Java el siguiente modelo sobre el Registro de Automotores, con seis clases (una de
ellas un actor), donde Formulario08 (que sirve tambin como clase asociativa para la relacin de

posesin) se utiliza para representar los datos de inscripcin de un Vehculo.
As, el Propietario de un Vehculo lo inscribe en el RNA (relacin inscribe), lo que implica la
creacin de un objeto Formulario08, para registrar la inscripcin (relacin de inscripcin).

? Cules son las diferentes formas de relaciones de asociacin.
3.10. Excepciones
Una excepcin es un tipo de error o condicin anormal que aparece durante la ejecucin de un
programa. Algunas excepciones crticas hacen que se deba finalizar la ejecucin del programa, por
ejemplo un fallo a nivel del hardware. Otras en cambio s son recuperables, como por ejemplo el no
encontrar un archivo del cual hay que leer datos.
Los sucesos que tienen lugar cuando se produce una excepcin son:
1. se interrumpe la ejecucin del cdigo del programa que se estaba ejecutando.
2. se crea un objeto de la clase que maneja ese tipo de excepciones y se pasa la referencia del
objeto creado, al mtodo que ha provocado el error.
3. finalmente el mtodo puede gestionar la excepcin (capturarla), o dejar que la trate el gestor
por defecto del intrprete Java. En este ltimo caso se mostrar un mensaje describiendo la
excepcin, la traza de la pila de llamadas desde el lugar donde se produjo la excepcin y se
finaliza el programa.
La gestin de excepciones en Java se especifica a travs de las siguientes palabras reservadas: try,
catch, throw, throws y finally.
Las sentencias try y catch forman una unidad. El objeto de la sentencia try es indicar que

sentencia/s puede llegar a producir una excepcin. El fin de la sentencia catch es indicar dnde se
resuelve la condicin que provoc la excepcin, para luego continuar la ejecucin del programa
como si el error no hubiese ocurrido.
Cuando surge una excepcin el control del programa se transfiere desde el bloque try al bloque
catch. Una vez que se ha ejecutado la sentencia catch, el control del programa contina en la lnea
siguiente despus del bloque try/catch.
Si resulta necesario forzar la ejecucin obligatoria de determinado cdigo al procesar un bloque try,
se indica agregando un bloque finally.
Forma de uso:
t r y {
/ / bl oque de cdi go que puede pr oduci r l as excepci ones Ti poExcepci n1, Ti poExcepci n2
}
cat ch ( Ti poExcepci n1 ex) {
/ / gest or de excepci ones par a Ti poExcepci n1
}
cat ch ( Ti poExcepci n2 ex) {
/ / gest or de excepci ones par a Ti poExcepci n2
}
f i nal l y {
/ / bl oque de cdi go que se ej ecut ar en f or ma obl i gat or i a,
/ / al f i nal i zar l a ej ecuci n del bl oque t r y o al guno de sus cat ch
}
Para especificar el lugar del programa donde se va a lanzar una excepcin, se utiliza la palabra
clave throw. Si un mtodo lanza una excepcin, esta debe ser especificada en la cabecera de la
declaracin del mtodo mediante la palabra throws.
EJEMPLO
class MiExcepcion extends Exception {
pr i vat e i nt codi go;
Mi Excepci on( i nt a) {
codi go = a;
}
publ i c St r i ng t oSt r i ng( ) {
r et ur n " Mi Excepci on[ " + codi go + " ] " ;
}
}
cl ass Pr uebaExcepci on {
st at i c voi d cal cul ar ( i nt a) throws Mi Excepci on {
Syst em. out . pr i nt l n( " Se l l ama a cal cul ar ( " + a + " ) " ) ;
i f ( a > 10) throw new MiExcepcion(a);
Syst em. out . pr i nt l n( " Sal i da nor mal " ) ;
}
publ i c st at i c voi d mai n( St r i ng ar gs[ ] ) {
try {
cal cul ar ( 1) ;
cal cul ar ( 20) ;
}
catch (MiExcepcion e) {
Syst em. out . pr i nt l n( " Capt ur ada " + e) ;
}
}
}
Si un mtodo redefine un mtodo de una superclase calificado con throws, el mtodo de la clase

derivada no tiene obligatoriamente que lanzar todas y cada una de las excepciones de la clase base.
Es posible en el mtodo de la subclase lanzar las mismas excepciones o menos, pero no puede
lanzar ms excepciones. No puede tampoco lanzar nuevas excepciones ni excepciones de una clase
ms general.
? Cmo se determina el acceso a un archivo de un package.

El lenguaje tiene definida una jerarqua de clases de excepciones, a la cual se le pueden agregar
nuevas clases.

Throwable
Error
LinkageError
ClassCircularityError
ClassFormatError
ExceptionInInitializerError
IncompatibleClassChangeError
AbstractMethodError
IllegalAccessError
InstantiationError
NoSuchFieldError
NoSuchMethodError
NoClassDefFoundError

UnsatisfiedLinkError
VerifyError
VirtualMachineError
InternalError
OutOfMemoryError
StackOverflowError
UnknownError
ThreadDeath
Exception
ClassNotFoundException
CloneNotSupportedException
IllegalAccessException
InstantiationException
InterruptedException
RuntimeException
ArithmeticException
ArrayStoreException
ClassCastException
IllegalArgumentException
IllegalThreadStateException
NumberFormatException
IllegalMonitorStateException
IndexOutOfBoundsException
NegativeArraySizeException
NullPointerException
SecurityException
? Cmo se captura una excepcin.
3.11. Threads
Los S.O permiten la multitarea, es decir, la realizacin simultnea de dos o ms actividades. En
realidad, una sola CPU no puede realizar dos actividades a la vez. Sin embargo los S.O. son capaces
de ejecutar varios programas simultneamente aunque slo se disponga de una CPU, repartiendo el
tiempo entre dos (o ms) procesos, o bien utilizan los tiempos muertos de una actividad (por
ejemplo, las operaciones de lectura de datos desde el teclado) para trabajar en la otra tarea.
En computadoras con dos o ms procesadores, o en clusters de computadoras, la multitarea es
real, ya que cada procesador puede ejecutar un proceso diferente.
Un proceso es un programa ejecutndose de forma independiente y con un espacio propio de
memoria. Un sistema operativo multitarea es capaz de ejecutar ms de un proceso simultneamente.
Un Thread (hilo) es un flujo secuencial simple dentro de un proceso. Un nico proceso puede tener
varios hilos ejecutndose. Las caractersticas bsicas de los tipos de multitarea son:
En base a procesos:
1. Permite a la computadora ejecutar ms de un
proceso concurrentemente.
2. La unidad de cdigo ms pequea es el
proceso.
3. Los procesos son tareas pesadas que
necesitan su propio espacio de
direccionamiento.
4. La comunicacin entre procesos es costosa y
limitada.
En base a hilos:
1. Un programa simple puede realizar ms de
una tarea simultneamente.
2. La unidad de cdigo ms pequea es el hilo.
3. Los hilos consumen menos recursos del S.O.
que los procesos.
4. Comparten el mismo espacio de direcciones
y el mismo proceso.
5. La comunicacin entre hilos es gil y el
cambio de contexto de un hilo al siguiente es

menos costoso.
Java hace uso de entornos multitarea basados en procesos, pero implementa esquemas de multitarea
basada en hilos, bajo el control de Java. La VM de Java utiliza un esquema de prioridades para
determinar cmo debe tratar cada hilo con respecto a los dems. La prioridad de un hilo se utiliza
para decidir cundo se va a ejecutar otro hilo (cambio de contexto).
3.11.1. Estados de un thread

Las causas que hacen que un hilo ceda el control son:
1. Un hilo puede ceder voluntariamente el control por abandono explcito, al dormirse o
bloquearse en espera de una operacin de E/S pendiente. Entonces se selecciona entre los hilos
restantes, el que tiene mayor prioridad, para darle el control.
2. Un hilo que no libera la CPU puede ser desalojado por otro de mayor prioridad. En el caso de
hilos de igual prioridad que compiten por la CPU, el S.O. decide a quien asignar CPU en base a
un algoritmo de planificacin de tareas.
Sincronizacin
Java implementa la sincronizacin entre procesos, por medio de un monitor. As, cada objeto tiene
su propio monitor, en el que se entra cuando se llama a uno de los mtodos sincronizados del
objeto. Una vez que un hilo est dentro de un mtodo sincronizado, ningn otro hilo puede llamar a
otro mtodo sincronizado del mismo objeto.
Intercambio de mensajes
Java tiene mtodos predefinidos que permiten que un hilo entre en un mtodo sincronizado de un
objeto, y espere ah hasta que otro hilo le notifique explcitamente que debe salir de l.

Mtodos
Para crear un nuevo hilo en Java, se debe crear una clase que herede de la clase Thread o que
implemente la interfaz Runnable. La clase Thread provee un conjunto de mtodos para manipular
los hilos, algunos de ellos son:
public final String getName()
public final int getPriority()
public final native boolean isAlive()
public final void join()
public final void resume()
public void run()
public static native void sleep(long millis)
public native synchronized void start()
public final void stop()
public final void suspend()
Obtiene el nombre de un hilo.
Obtiene la prioridad de un hilo.
Comprueba si un hilo se est ejecutando.
Espera hasta que finalice el hilo sobre el que se llama.
Reanuda la ejecucin de un hilo suspendido.
Mtodo principal para ejecutar un hilo.
Suspende un hilo durante un perodo de tiempo
Comienza la ejecucin un hilo llamando a run().
Detiene la ejecucin de un hilo.
Suspende la ejecucin un hilo.
Creacin de un hilo
Cuando se ejecuta un programa Java se crea un hilo, llamado hilo principal, desde donde se crean el
resto de hilos del programa.
El mtodo run() es la funcin inicial de arranque, de un nuevo hilo de ejecucin concurrente
dentro de un programa. Un hilo termina cuando finaliza el mtodo run().
Para que un hilo comience su ejecucin se debe activar el mtodo start().
EJEMPLO
cl ass Mi Thr ead ext ends Thr ead {
Mi Thr ead( ) {
super ( " Padr e" ) ;
Syst em. out . pr i nt l n( " Hi j o: " + t hi s) ;
}
publ i c voi d r un( ) {
t r y {
f or ( i nt i = 0; i < 5; i ++) {
Syst em. out . pr i nt l n( " Hi j o: " + i ) ;
Thr ead. sl eep( 500) ;
}
}
cat ch ( I nt er r upt edExcept i on e) {
Syst em. out . pr i nt l n( " Hi j o i nt er r umpi do" ) ;
}
Syst em. out . pr i nt l n( " Ter mi na hi j o" ) ;
}
}
cl ass Pr uebaThr ead {
publ i c st at i c voi d mai n( St r i ng ar gs[ ] ) {
Mi Thr ead obj = new Mi Thr ead( ) ;
obj . st ar t ( ) ;
t r y {
f or ( i nt i = 0; i < 5; i ++) {
Syst em. out . pr i nt l n( " Pr ogr ama: " + i ) ;
Thr ead. sl eep( 1000) ;
}
}
cat ch ( I nt er r upt edExcept i on e) {
Syst em. out . pr i nt l n( " Pr ogr ama i nt er r umpi do" ) ;
}
Syst em. out . pr i nt l n( " Ter mi na pr ogr ama" ) ;
}
}


? Cul es la diferencia entre proceso y thread.

3.12. Asserts
Un assert es una afirmacin categrica o condicin, que se quiere imponer durante la ejecucin de
un programa y consiste en una instruccin que contiene una expresin booleana de la que se sabe,
que en un momento dado de la ejecucin del programa se debe evaluar a verdadero. Esto est
relacionado con los conceptos de precondiciones, postcondiciones y los invariantes, de la
verificacin formal de programas.
Los asserts, junto con el manejo de excepciones, permiten reducir la posibilidad de errores en un
programa.
Para declarar un assert en una clase Java, se usa la siguiente sintaxis:
assert Expresion1;
assert Expresin1:Expresin2;
En cualquiera de los dos casos Expresin1 tiene que ser una expresin booleana. Cuando se evala
un assert que solo tenga Expresin1, se comprueba la veracidad de la expresin y si es verdadera se
contina la ejecucin del programa, pero si es falsa, se lanza una excepcin de tipo AssertionError.
Si el assert contiene tambin la Expresin2 y la Expresin1 es falsa, se evala Expresion2 y se le

pasa como parmetro al constructor del AssertionError (si Expresion1 es verdadera, la segunda
expresin no se evala).
Compilacin
Para que el compilador del JDK acepte la instruccin, se le debe pasar como parmetro -source 1.4.
Por ejemplo:
javac -source 1.4 Assert.java
Esto le indica al compilador que el cdigo que recibe utiliza caractersticas del lenguaje aparecidas
en la versin 1.4 del JDK.
Activacin/Desactivacin
Las asserts estn pensados para la comprobacin de invariantes (condiciones que se cumplen
siempre en un determinado trozo de cdigo), por lo que tienen mas inters en la etapa de desarrollo.
Por esto se puede desactivar y activar la comprobacin de los asserts. Por defecto la comprobacin
de los asserts esta desactivada y se proporcionan dos opciones para el intrprete del JDK (java).
java -enableassertions (-ea), para activar la comprobacin.
java -disableassertions (-da), para desactivar la comprobacin.
Estos modificadores, activarn o desactivarn la comprobacin de asserts para la clase que se
pretende ejecutar.
Para activar/desactivar la comprobacin de los asserts en un determinado paquete o de una
determinada clase:
java -enableassertions:Saludos.Hola... HolaMundo
(Activa asserts en el paquete Saludos.Hola, por los puntos ...)
java -enableassertions:Saludos.Hola HolaMundo
(Activa asserts la clase Saludos.Hola, por que no lleva puntos)
Y lo mismo para disable:
java -disablessertions:Saludos.Hola... HolaMundo
java -disableassertions:Saludos.Hola HolaMundo
Tambin se puede activar para unos y desactivar para otros:
java -ea:Camion.Rueda... -da:Camion.Freno Camion.Conducir
La sintaxis es la siguiente:
java [-enableassertions | -ea] [:<package name>"..." | :<class name>]
java [-disableassertions | -da] [:<package name>"..." | :<class name>]

Los asserts son muy tiles, durante la etapa de depuracin de errores y verificacin de
comportamiento de un programa complejo.
Veamos algunos ejemplos:
i f ( a==1) {

. . .
} el se i f ( a==2) {
. . .
} el se { / / cuando a==3
. . .
}
Aqu sera til aplicar la instruccin assert:
i f ( a==1) {
. . .
} el se i f ( a==2) {
. . .
} el se {
asser t ( a==3)
. . .
}
De esta manera se protege el else, ya que si se pasa por el else y el assert no se cumple, se genera
un AssertionError.
Otro caso para los asserts es una sentencia switch que no tenga clusula default. En este caso el
assert comprobar que nunca se entra por el default:
swi t ch ( suer t e) {
case Moneda. CARA:
. . .
r et ur n;
case Moneda. CRUZ:
. . .
r et ur n;
case def aul t :
asser t f al se;
}
Se habr dado cuenta de la potencia de utilizar assert false en cualquier lugar del programa donde se
supone no se debe entrar nunca.
Para verificar que la comprobacin de que asserts est activada, podemos hacer lo siguiente:
st at i c {
bool ean asser t sAct i vado = f al se;
asser t asser t sAct i vado = t r ue;
i f ( ! asser t sAct i vado)
t hr ow new Runt i meExcept i on( " Debe act i var l a compr obaci on de asser t s! " ) ;
}
El cdigo es esttico, por lo que siempre se ejecutar. Si la comprobacin de asserts esta
desactivada no se har caso del assert y se generar la excepcin RuntimeException, en cambio si
esta activada, se cambiar el valor de assertsActivado y no se generar la excepcin.
3.13. Programacin estructurada vs. O.O.
Comparemos estos dos programas que trabajan con un arreglo unidimensional de enteros, para ver
las diferencias de implementacin.

Estructurado (en C) O.O. (en Java)
#i ncl ude <st di o. h>
voi d per mut a( i nt & a, i nt & b) {
i nt c = a;
a = b;
b = c;
}
voi d or denar ( i nt v[ ] , i nt n) {
i nt i , j ;
f or ( i = 0; i < n 1; i ++)
f or ( j = i ; j < n; j ++)
i f ( v[ i ] > v[ j ] ) per mut a( v[ i ] , v[ j ] ) ;
}
voi d most r ar ( i nt v[ ] , i nt n) {
i nt i ;
f or ( i = 0; i < n; i ++) pr i nt f ( %d, v[ i ] ) ;
}

voi d mai n( ) {
i nt c = 7, v[ ] = {6, 3, 8, 2, 1, 5, 4};
or denar ( v, c) ;
most r ar ( v, c) ;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
i mpor t j ava. i o. *;
cl ass ARREGLO {
pr i vat e i nt n = 7;
pr i vat e i nt [ ] v = {6, 3, 8, 2, 1, 5, 4};
pr i vat e voi d per mut a( i nt a, i nt b) {
i nt c = v[ a] ;
v[ a] = v[ b] ;
v[ b] = c;
}
publ i c voi d or denar ( ) {
i nt i , j ;
f or ( i = 0; i < n - 1; i ++)
f or ( j = i ; j < n; j ++)
i f ( v[ i ] > v[ j ] ) per mut a( i , j ) ;
}
publ i c voi d most r ar ( ) {
i nt i ;
f or ( i = 0; i < n; i ++)
Syst em. out . pr i nt l n( v[ i ] ) ;
}
}
publ i c cl ass pr ogr ama{
ARREGLO a = new ARREGLO( ) ;
a. or denar ( ) ;
a. most r ar ( ) ;
}
}
1: El enunciado import tiene un significado semejante al del #include, pero la implementacin del
proceso es completamente diferente.
2: La especificacin de la clase ARREGLO (entre las lneas 2 a 21) implementa la abstraccin del
concepto de arreglo unidimensional.
3, 4: Se declaran los atributos que describen el concepto de arreglo (espacio de almacenamiento
para el arreglo y dimensin). Estas variables - se denominan de instancia - no son accesibles desde
afuera de la clase, debido a que estn calificadas como privadas.
5 a 9: Se implementa una funcin (mtodo) que se utiliza para fines internos de la clase, por lo
cual se la ha calificado como privada. Observemos que mientras a la funcin en C, se le pasan por
referencia los valores que debe permutar, ya que no tiene acceso al arreglo por estar definido en el
ambiente de referencia local de la funcin main; en el caso de Java se le pasan los valores de los
subndices de los elementos a permutar, ya que en este caso si tiene acceso al arreglo.
10 a 20: Se especifican tres funciones (mtodos) que son los que implementan las funcionalidades
que la clase ARREGLO ofrece. Al ser calificado como pblico, se permite el acceso libre y se
puede activar a la funcin, desde mtodos que pertenezcan a otras clases. Observemos que en
ningn caso es necesario pasar argumentos, ya que cada funcin (mtodo) tiene acceso a los
atributos que describen al arreglo.

22: Se define la clase que describe al programa principal, ya que en Java todo debe programarse con
clases. Esta clase tiene un nico mtodo, que es el main, cuya funcin sera semejante a la que
cumple la funcin main en C, o sea ejecutar el programa principal.
24: Se declara una variable del tipo ARREGLO y con new se crea un objeto de ese tipo. En Java los
objetos de datos no primitivos (en este caso un arreglo), siempre deben crearse en forma dinmica.
25 y 26: Se activan los mtodos del objeto referenciado por la variable a, que efectan el
ordenamiento del arreglo y lo muestran por pantalla. Esto es lo que en la metodologa O.O. se le
denomina enviar un mensaje a un objeto.
4. RESUMEN COMPARATIVO ENTRE JAVA Y SMALLTALK
Java
Referencias
Smalltalk

Null
This
Super
this.getClass()
nil
self
super
self class
Variables de instancia
X
this.x
anObject.x

x
x

Clases e interfaces
class Foo {
class Bar extends Foo {
interface Foo {
class Bar implements Foo {

Object subclass: #Foo
Bar subclass: #Foo

Envo de mensajes
3 + 4 * 2 //da 11
3 + (4 * 2) //da 11
anObject.foo()
foo()
anObject.foo(a,b)
anObject.firstMessage(). secondMessage().lastMessage();

3 + 4 * 2 da 14
3 + (4 * 2) da 11
anObject foo
self foo
anObject foo: a with: b
anObject firstMessage; secondMessage; lastMessage.
Tipos y variables

int a, b;
a = b = 3 + 4;
Object anObject;
int anInt;
Object foo()

| a b |
a := b := 3 + 4.
| anObject |

foo
Control de acceso
public int foo()
protected foo()
public x
protected x
private x

foo

x

Conversiones de tipos
x instanceof Bar
(Bar) x

x isKindOf: Bar
x respondsTo: #messageForABar
Enunciados de control
if (isTrue) {}
if (...) {} else {}
switch (...)
while (...)
do {} while ()
for (...; ...; ...)

try {} catch(Exception e){}
(isTrue) ifTrue: []
(...) ifTrue: [] ifFalse:[]

(...) whileTrue: []

anInterval do: (number) timesRepeat:[]
aCollection do:, collect:, etc.
Exception handle: [:e|...] do: [...]
EJEMPLO
SmallTalk
BankAccount subclass: #SavingsAccount
instanceVariableNames: 'balance name'
initializeBalance: anInteger name: aString
balance :=anInteger.
name :=aString.
^self
balance
^balance
SavingsAccount new initializeBalance: 100 name: 'Dave'.
Java

class SavingsAccount extends BankAccoun {
private int balance;
private String name;
public Object initializeBalance(int anInteger, String aString) {
balance =aninteger;
name =aString;
return this;
}
public int balance() {return balance ; }
}
new SavingsAccount().initializeBalance(100, Dave);

Introducción Al Paradigma Lógico, Funcional y Orientado A Objetos

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Introducción Al Paradigma Lógico, Funcional y Orientado A Objetos

Diunggah oleh

Hak Cipta:

Format Tersedia

GUA DE ESTUDIO

Anda mungkin juga menyukai