Notas POO 2008

PROGRAMACIN ORIENTADA
A OBJETOS
CON C++, JAVA Y RUBY

Notas de clase

C++

Elaborado por:
Carlos Alberto Fernndez y Fernndez
Instituto de Electrnica y Computacin
Universidad Tecnolgica de la Mixteca
Primavera 2008
Programacin Orientada a Objetos
con C++, J ava y Ruby
- 2 -

Contenido

Eclipse ................................................................................................................ 12
Caractersticas de C++...................................................................................... 15
Comentarios en C++........................................................................................ 15
Flujo de entrada/salida..................................................................................... 15
Funciones en lnea............................................................................................ 16
Declaraciones de variables............................................................................... 18
Operador de resolucin de alcance .................................................................. 19
Valores por Default .......................................................................................... 21
Parmetros por referencia................................................................................ 23
Variables de referencia...................................................................................24
Asignacin de memoria en C++....................................................................... 26
Plantillas .......................................................................................................... 30
Introduccin a la programacin orientada a objetos [2, 3] ............................ 34
Programacin no estructurada......................................................................... 34
Programacin procedural ................................................................................ 34
Programacin modular..................................................................................... 35
Datos y Operaciones separados ....................................................................... 36
Programacin orientada a objetos ................................................................... 37
Tipos de Datos Abstractos ................................................................................ 38
Los Problemas................................................................................................38
Tipos de Datos Abstractos y Orientacin a Objetos.......................................39
Conceptos de bsicos de objetos....................................................................... 40
Lenguajes de programacin orientada a objetos .............................................. 43
- 3 -
C.....................................................................................................................44
Introduccin a Java........................................................................................... 46
Origen............................................................................................................... 46
Caractersticas de diseo.................................................................................. 47
Simple y familiar............................................................................................47
Orientado a Objetos........................................................................................48
Independiente de la plataforma.......................................................................48
Portable..........................................................................................................49
Robusto..........................................................................................................49
Diferencias entre Java y C++ .......................................................................... 51
Archivos .java y .class ...................................................................................... 53
Programas generados con java ........................................................................ 53
El Java Developers Kit .................................................................................... 54
Compilacin...................................................................................................54
Hola Mundo ................................................................................................. 56
Hola mundo bsico en J ava............................................................................56
Hola mundo bsico en C++............................................................................57
Hola mundo en un J ava Applet.......................................................................57
Archivo HTML ..............................................................................................59
Ejecucin........................................................................................................59
Hola mundo en Eclipse...................................................................................60
Fundamentos del Lenguaje Java...................................................................... 61
Comentarios ..................................................................................................... 61
Tipos de datos................................................................................................... 62
Tipos de datos simples...................................................................................63
Referencias a objetos......................................................................................64
Identificadores.................................................................................................. 64
Variables .......................................................................................................... 65
mbito de una variable. .................................................................................66
- 4 -
Operadores ....................................................................................................... 69
Operadores aritmticos:..................................................................................69
Operadores relacionales: ................................................................................71
Operadores lgicos:........................................................................................72
Operadores de bits:.........................................................................................73
Operadores de asignacin:..............................................................................74
Precedencia de operadores en J ava.................................................................74
Valores literales................................................................................................ 75
Literales lgicos.............................................................................................75
Literales de tipo entero...................................................................................76
Literales de tipo real .......................................................................................76
Literales de tipo carcter ................................................................................77
Literales de tipo String...................................................................................78
Estructuras de control ...................................................................................... 79
Estructuras condicionales...............................................................................79
Ciclos. ............................................................................................................83
Saltos..............................................................................................................87
Arreglos ............................................................................................................ 88
Enumeraciones ................................................................................................. 92
Introduccin a Ruby ......................................................................................... 94
Caractersticas ................................................................................................. 94
Comparado con C...........................................................................................95
Comparado con C++......................................................................................96
Comparado con J ava......................................................................................97
Herramientas.................................................................................................... 98
Ruby: Fundamentos del lenguaje..................................................................... 99
Convenciones lxicas........................................................................................ 99
Literales.......................................................................................................... 100
Variables ........................................................................................................ 101
Operadores ..................................................................................................... 103
- 5 -
Arreglos .......................................................................................................... 106
Probando Ruby............................................................................................... 109
Estructuras de control .................................................................................... 110
Entrada y Salida bsica en Ruby .................................................................... 118
Abstraccin de datos: Clases y objetos .......................................................... 119
Clases ............................................................................................................. 119
Objetos e instancias........................................................................................ 120
Instanciacin................................................................................................120
Clases en C++................................................................................................ 121
Miembros de una clase en C++...................................................................... 122
Atributos miembro.......................................................................................122
Mtodos miembro........................................................................................122
Un vistazo al acceso a miembros..................................................................124
Objetos de clase en C++................................................................................ 126
Clases en Java ................................................................................................ 129
Miembros de una clase en Java ...................................................................... 130
Mtodos miembro........................................................................................131
Un vistazo al acceso a miembros..................................................................131
Objetos de clase en Java................................................................................. 132
Asignacin de memoria al objeto.................................................................132
Clases en Ruby ............................................................................................... 136
Miembros de una clase en Ruby ..................................................................... 136
Mtodos miembro........................................................................................137
Un vistazo al acceso a mtodos....................................................................138
Objetos de clase en Ruby................................................................................ 140
Asignacin de memoria al objeto.................................................................140
Alcance de Clase en C++............................................................................... 144
- 6 -
Alcance de Clase en Java ............................................................................... 144
Alcance de Clase en Ruby............................................................................... 145
Usando la palabra reservada this en C++ y Java .......................................... 146
Usando la palabra reservada self en Ruby ..................................................... 147
Sobrecarga de operaciones............................................................................. 148
Constructores y destructores en C++............................................................. 150
Constructor...................................................................................................150
Constructor de Copia....................................................................................151
Destructor.....................................................................................................153
Constructores y finalizadores en Java ............................................................ 156
Constructor...................................................................................................156
Finalizador ...................................................................................................157
Inicializadores en Ruby .................................................................................. 158
Miembros estticos en C++ ........................................................................... 160
Miembros estticos en Java............................................................................ 163
Miembros de clase en Ruby ............................................................................ 166
Atributos de clase.........................................................................................166
Mtodos de clase..........................................................................................166
Objetos constantes en C++ ............................................................................ 168
Objetos finales en Java................................................................................... 171
Objetos constantes en Ruby ............................................................................ 173
Funciones amigas en C++ ............................................................................... 176
Sobrecarga de operadores en C++ ................................................................. 181
Algunas restricciones: .................................................................................... 181
Sobrecarga de operadores en Ruby ............................................................... 191
Herencia en C++.............................................................................................. 193
- 7 -
Introduccin ................................................................................................... 193
Implementacin en C++................................................................................. 194
Control de Acceso a miembros en C++.......................................................... 196
Control de acceso en herencia en C++.......................................................... 198
Manejo de objetos de la clase base como objetos de una clase derivada y
viceversa en C++ ........................................................................................... 202
Constructores de clase base en C++.............................................................. 206
Redefinicin de mtodos en C++.................................................................... 209
Herencia Mltiple en C++ ............................................................................. 212
Ambigedades..............................................................................................216
Constructores en herencia mltiple..............................................................220
Herencia en Java ............................................................................................. 221
Implementacin en Java ................................................................................. 221
BlueJ............................................................................................................... 223
Clase Object ................................................................................................... 226
Control de acceso a miembros en Java........................................................... 227
Control de acceso de clase public en Java...................................................... 230
Constructores de superclase........................................................................... 230
Manejo de objetos de la subclase como objetos de una superclase en Java ... 231
Redefinicin de mtodos ................................................................................. 235
Calificador final ............................................................................................. 237
Interfaces ......................................................................................................... 238
Herencia en Ruby............................................................................................ 243
Implementacin en Ruby................................................................................. 243
Clase Class ..................................................................................................... 244
Clase Object ................................................................................................... 245
- 8 -
Control de acceso a miembros en Ruby.......................................................... 246
Inicializadores de superclase.......................................................................... 249
Manejo de objetos de la subclase como objetos de una superclase en Ruby... 250
Redefinicin de mtodos ................................................................................. 252
Mdulos............................................................................................................ 254
Mixins............................................................................................................... 255
Asociaciones entre clases en C++ ................................................................... 259
Asociaciones reflexivas en C++..................................................................... 261
Multiplicidad de una asociacin en C++....................................................... 262
Tipos de asociaciones segn su multiplicidad..............................................262
Asociaciones entre Clases en Java.................................................................. 266
Asociacin reflexiva en Java .......................................................................... 267
Multiplicidad de una asociacin en Java........................................................ 267
Asociaciones entre Clases en Ruby ................................................................ 271
Asociacin reflexiva en Ruby.......................................................................... 271
Multiplicidad de una asociacin en Ruby ....................................................... 272
Objetos compuestos en C++............................................................................ 273
UMLGEC ++................................................................................................... 277
Objetos compuestos en Java........................................................................... 279
Objetos compuestos en Ruby.......................................................................... 284
Funciones virtuales y polimorfismo en C++.................................................. 289
Clase abstracta y clase concreta en C++....................................................... 292
- 9 -
Polimorfismo .................................................................................................. 293
Destructores virtuales..................................................................................... 294
Clases Abstractas y Polimorfismo en Java .................................................... 309
Clase abstracta y clase concreta en Java ....................................................... 311
Ejemplo de Polimorfismo con una Interfaz en Java........................................ 323
Polimorfismo en Ruby .................................................................................... 325
Y la clase abstracta?..................................................................................... 327
Plantillas de clase en C++ ............................................................................... 337
Standard Template Library (STL) ................................................................ 341
Clases Genricas en Java................................................................................. 344
Biblioteca de Clases Genricas en Java ......................................................... 347
Manejo de Excepciones ................................................................................... 350
Manejo de Excepciones en C++...................................................................... 351
Excepciones estandar en C++........................................................................ 352
Manejo de Excepciones en Java ..................................................................... 354
Cmo funciona?............................................................................................ 354
Lanzamiento de excepciones (throw) .............................................................. 355
Manejo de excepciones ................................................................................... 356
El bloque try.................................................................................................357
El bloque catch.............................................................................................357
El bloque finally...........................................................................................359
Jerarqua de excepciones................................................................................ 361
Ventajas del tratamiento de excepciones......................................................362
- 10 -
Lista de Excepciones ...................................................................................363
Afirmaciones en Java...................................................................................... 367
Usando afirmaciones ...................................................................................... 367
Habilitando y deshabilitando las afirmaciones............................................... 368
Manejo de Excepciones en Ruby.................................................................... 370
Raise & Rescue............................................................................................... 370
Jerarqua de Excepciones ............................................................................... 372
Catch & Throw............................................................................................... 373
Introduccin a Multihilos en Java ................................................................. 375
Programas de flujo mltiple.........................................................................375
Estados de un hilo........................................................................................... 377
La clase Thread .............................................................................................. 379
Comportamiento de los hilos .......................................................................... 380
Interfaz Grfica AWT .................................................................................... 383
Clases de ventana ........................................................................................... 383
Clase Frame..................................................................................................384
Clase Dialog.................................................................................................384
Clase Filedialog............................................................................................384
Componentes grficos .................................................................................... 385
Aplicaciones con mens.................................................................................. 390
Clase MenuBar.............................................................................................390
Clase Menu..................................................................................................390
Clase MenuItem...........................................................................................391
Manejo de Eventos .......................................................................................... 394
Introduccin ................................................................................................... 394
Modelo de manejo de eventos actual .............................................................. 395
- 11 -
Adaptadores.................................................................................................399
Otras tecnologas Java .................................................................................... 407
Principales tecnologas de Java EE................................................................ 408
Otras tecnologas (no necesariamente Java).................................................. 410
Referencias....................................................................................................... 413
- 12 -
Eclipse

Eclipse es desarrollado como un proyecto de codigo abierto lanzada en
noviembre de 2001 por IBM, Object Technology Internacional y otras compaias.
El objetivo era desarrollar una plataforma abierta de desarrollo. Fue planeada para
ser extendida mediante plug-ins.

Es desarrollada en J ava por lo que puede ejecutarse en un amplio rango de
sistemas operativos. Tambien incorpora facilidades para desarrollar en J ava
aunque es posible instalarle plug-ins para otros lenguajes como C/C++, PHP,
Ruby, Haskell, etc. Incluso antiguos lenguajes como Cobol tienen extensiones
disponibles para Eclipse [1]:

Eclipse +J DT =J ava IDE
Eclipse +CDT =C/C++IDE
Eclipse +PHP =PHP IDE
Eclipse +J DT +CDT +PHP =J ava, C/C++, PHP IDE

Trabaja bajo workbenchs que determinan la interfaz del usuario centrada
alrededor del editor, vistas y perspectivas.
- 13 -

Los recursos son almacenados en el espacio de trabajo (workspace) el cual es un
flder almacenado normalmente en el directorio de Eclipse. Es posible manejar
diferentes reas de trabajo.

Eclipse, sus componentes y documentacin pueden ser obtenidos de:
www.eclipse.org

Para trabajar en este curso se requerir preferentemente:

1. J ava 1.5 o 1.6
2. Eclipse SDK 3.3.x
3. Plug in para C/C++en Eclipse (CDT) y compilador de ANSI C/C++si no
se tiene uno instalado.
4. Ruby 1.8
- 14 -
5. Plug in para Ruby (RDT Rubt Development Tools) si se quiere usar Ruby
con Eclipse

Tips para instalar CDT (C/C++ Development Toolkit) en Eclipse en Windows:

1. Instalar un compilador de C/C++
a. Si se instala MinGW y se tiene que renombrar el archivo mingw32-
make.exe por make.exe. Ver http://www.mingw.org
b. Adems, aadir el depurador gdb pues no viene incluido en MinGW,
aunque existe una copia en el sitio antes mencionado o puede
obtenerse de: http://sourceware.org/gdb
2. Instalar el CDT desde el sitio recomendado Usando el Update Manager y
obteniendo el plug in del sitio Callisto Discovery que aparece listado al
entrar a aadir componentes en el Update Manager (Otra opcion es ir a
http://www.eclipse.org/cdt/ )
3. Agregar \MinGW\bin (o el directorio correspondiente) al la variable PATH
del sistema.

Si el CDT esta bien instalado debe ser posible crear proyectos de C/C++,
compilarlos, ejecutarlos y depurarlos dentro del ambiente de Eclipse.

En el caso de Ruby, el interprete puede obtenerse de: http://www.ruby-
lang.org/en/downloads/

El RDT para eclipse se instala como el CDT y se obtiene de:
http://rubyeclipse.sourceforge.net/download.rdt.html

Posteriormente se tiene que especificar en Eclipse la ruta del interprete.

- 15 -
Caractersticas de C++

Ahora comentaremos algunas caractersticas de C++que no tienen que ver
directamente con la programacin orientada a objetos.

Comentarios en C++

Los comentarios en C son:

/ * coment ar i o en C */

En C++los comentarios pueden ser adems de una sola lnea:

/ / est e es un coment ar i o en C++

Acabando el comentario al final de la lnea, lo que quiere decir que el
programador no se preocupa por cerrar el comentario.

Flujo de entrada/sali da

En C, la salida y entrada estndar estaba dada por printf y scanf principalmente
(o funciones similares) para el manejo de los tipos da datos simples y las cadenas.
En C++se proporcionan a travs de la librera i ost r eam, la cual debe ser
insertada a travs de un #i ncl ude. Las instrucciones son:

- cout Utiliza el flujo salida estndar.
Que se apoya del operador <<, el cual se conoce como operador
de insercin de flujo "colocar en"

- cin Utiliza el flujo de entrada estndar.
Que se apoya del operador >>, conocido como operador de
extraccin de flujo "obtener de"

- 16 -
Los operadores de insercin y de extraccin de flujo no requieren cadenas
de formato (%s, %f), ni especificadores de tipo. C++ reconoce de manera
automtica que tipos de datos son extrados o introducidos.

En el caso de el operador de extraccin (>>) no se requiere el operador de
direccin &.

De tal forma un cdigo de desplegado con printf y scanf de la forma (usando
el area de nombres estandar):

pr i nt f ( " Nmer o: " ) ;
scanf ( " %d" , &num) ;
pr i nt f ( " El val or l e do es: " %d\ n" , num) ;

Sera en C++de la siguiente manera:

cout << " Nmer o" ;
ci n >> num;
cout << " El val or l e do es: " << num<< ' \ n' ;

Funciones en l nea

Las funciones en lnea, se refiere a introducir un calificador inline a una
funcin de manera que le sugiera al compilador que genere una copia del cdigo
de la funcin en lugar de la llamada.

Ayuda a reducir el nmero de llamadas a funciones reduciendo el tiempo de
ejecucin en algunos casos, pero en contraparte puede aumentar el tamao del
programa.

A diferencia de las macros, las funciones inline si incluyen verificacin de
tipos y son reconocidas por el depurador.
Las funciones inline deben usarse slo para funciones chicas que se usen
frecuentemente.

- 17 -
El compilador desecha las solicitudes inline para programas que incluyan un
ciclo, un switch o un goto. Tampoco se consideran si no tienen return (aunque no
regresen valores) o si contienen variables de tipo static. Y lgicamente no genera
una funcin inline para funciones recursivas.

Declaracin:

inline <decl ar aci n de l a f unci n>

Ejemplo:

inline float suma ( float a, float b) {
Ret ur n a+b;
}

inline int max( int a, int b) {
return ( a > b) ? a : b;
}

Nota: Las funciones inline tienen conflictos con los prototipos, as que
deben declararse completas sin prototipo en el archivo .h. Adems, si la funcin
hace uso de otra funcin en donde se expanda la funcin debe tener los include
correspondientes a esas funciones utilizadas.

- 18 -
Decl araci ones de variables

Mientras que en C, las declaraciones deben ir en la funcin antes de
cualquier lnea ejecutable, en C++pueden ser introducidas en cualquier punto,
con la condicin lgica de que la declaracin est antes de la utilizacin de lo
declarado.

En algunos compiladores podia declararse una variable en la seccin de
inicializacin de la instruccin for, pero es incorrecto declarar una variable en la
expresin condicional del while, do-while, for, if o switch. El actual estandar de
C++no permite la declaracion de variables dentro del for.

Ejemplo:

#include 

int mai n( ) {
int i =0;

for ( i =1; i <10; i ++) {
int j =10;
st d: : cout <<i <<" j : " <<j <<st d: : endl ;
}

st d: : cout <<" \ ni al sal i r del ci cl o: " <<i ;

return 0;
}

- 19 -
O usando el area de nombres estandar:


using namespace st d;

int mai n( ) {
int i =0;

for ( i =1; i <10; i ++) {
int j =10;
cout <<i <<" j : " <<j <<endl ;
}

cout <<" \ ni al sal i r del ci cl o: " <<i ;

return 0;
}

El alcance de las variables en C++es por bloques. Una variable es vista a
partir de su declaracin y hasta la llave } del nivel en que se declar. Lo cual
quiere decir que las instrucciones anteriores a su declaracin no pueden hacer uso
de la variable, ni despus de finalizado el bloque.

Operador de resol ucin de alcance

Se puede utilizar el operador de resolucin de alcance :: se refiere a una
variable (variable, funcin, tipo, enumerador u objeto), con un alcance de archivo
(variable global).
Esto le permite al identificador ser visible an si el identificador se
encuentra oculto.

Ejemplo:

float h;
- 20 -

void g( int h) {
float a;
int b;

a=: : h; / / a se i ni ci al i za con l a var i abl e gl obal h

b=h; / / b se i ni ci al i za con l a var i abl e l ocal h
}

- 21 -
Valores por Defaul t

Las funciones en C++pueden tener valores por default. Estos valores son
los que toman los parmetros en caso de que en una llamada a la funcin no se
encuentren especificados.

Los valores por omisin deben encontrarse en los parmetros que estn ms
a la derecha. Del mismo modo, en la llamada se deben empezar a omitir los
valores de la extrema derecha.

Ejemplo:



int punt o( int=5, int=4) ;

int mai n ( ) {

cout <<" val or 1: " <<punt o( ) <<' \ n' ;
cout <<" val or 2: " <<punt o( 1) <<' \ n' ;
cout <<" val or 3: " <<punt o( 1, 3) <<' \ n' ;
get char ( ) ;
return 0;
}

int punt o( int x, int y) {

if( y! =4)
return y;
if( x! =5)
return x;
return x+y;
}

- 22 -
C++no permite la llamada omitiendo un valor antes de la extrema derecha
de los argumentos:

punt o( , 8) ;

Otro ejemplo de valores o argumentos por default:



int b=1;
int f ( int) ;
int h( int x=f ( b) ) ; / / ar gument o def aul t f ( : : b)

int mai n ( ) {
b=5;
cout <<b<<endl ;
{
int b=3;
cout <<b<<endl ;
cout <<h( ) ; / / h( f ( : : b) )
}

return 0;
}

int h( int z) {
cout <<" Val or r eci bi do: " <<z<<endl ;
return z*z;
}
int f ( int y) {
return y;
}

- 23 -
Parmetros por referencia

En C todos los pasos de parmetros son por valor, aunque se pueden enviar
parmetros "por referencia" al enviar por valor la direccin de un dato (variable,
estructura, objeto), de manera que se pueda accesar directamente el rea de
memoria del dato del que se recibi su direccin.
C++introduce parmetros por referencia reales. La manera en que se
definen es agregando el smbolo & de la misma manera que se coloca el *:
despus del tipo de dato en el prototipo y en la declaracin de la funcin.

Ejemplo:

/ / Compar ando par met r os por val or , por val or con
/ / apunt ador es ( " r ef er enci a" ) ,
/ / y paso por r ef er enci a r eal



int por Val or ( int) ;
void por Apunt ador ( int *) ;
void por Ref er enci a( int &) ;

int mai n( ) {
int x=2;
cout << " x= " << x << " ant es de l l amada a por Val or \ n"
<< " Regr esado por l a f unci n: " << por Val or ( x) <<endl
<< " x= " << x << " despues de l a l l amada a
por Val or \ n\ n" ;

int y=3;
cout << " y= " << y << " ant es de l l amada a
por Apunt ador \ n" ;
por Apunt ador ( &y) ;
cout << " y= " << y << " despues de l a l l amada a
por Apunt ador \ n\ n" ;

- 24 -
int z=4;
cout << " z= " << z << " ant es de l l amada a por Ref er enci a
\ n" ;
por Ref er enci a( z) ;
cout << " z= " << z << " despues de l a l l amada a
por Ref er enci a\ n\ n" ;

return 0;
}

int por Val or ( int val or ) {
return val or *=val or ; / / par met r o no modi f i cado
}

void por Apunt ador ( int *p) {
*p *= *p; / / par met r o modi f i cado
}

void por Ref er enci a( int &r ) {
r *= r ; / / par met r o modi f i cado
}

Notar que no hay diferencia en el manejo de un parmetro por referencia y
uno por valor, lo que puede ocasionar ciertos errores de programacin.

Variables de referencia

Tambin puede declararse una variable por referencia que puede ser
utilizada como un seudnimo o alias. Ejemplo:

int max=1000, &sMax=max; / / decl ar o max y sMax es un al i as
de max
sMax++; / / i ncr ement o en uno max a t r avs de su al i as

Esta declaracin no reserva espacio para el dato, pues es como un apuntador
pero se maneja como una variable normal. No se permite reasignarle a la variable
por referencia otra variable.
- 25 -

Ejemplo:

/ / var i abl e por r ef er enci a



int mai n( ) {
int x=2, &y=x, z=8;

cout << " x= " <<x <<endl
<<" y= " <<y<<endl ;

y=10;
cout << " x= " <<x <<endl
<<" y= " <<y<<endl ;
/ / Reasi gnar no est a per mi t i do
/ * &y=&z;
cout << " z= " <<z <<endl
<<" y= " <<y<<endl ;
*/
y++;
cout << " z= " <<z <<endl
<<" y= " <<y<<endl ;

return 0;
}

- 26 -
Asignaci n de memoria en C++

En el ANSI C, se utilizan malloc, calloc y free para asignar y liberar
dinmicamente memoria:

float *f ;
f = ( float *) mal l oc( sizeof( float) ) ;
. . .
f r ee( f ) ;

Se debe indicar el tamao a travs de sizeof y utilizar una mscara (cast)
para designar el tipo de dato apropiado.

En C++, existen dos operadores para asignacin y liberacin de memoria
dinmica: new y delete.

float *f ;
f = new float;
. . .
delete f ;

El operador new crea automticamente un rea de memoria del tamao
adecuado. Si no se pudo asignar le memoria se regresa un apuntador nulo (NULL
0). Ntese que en C++se trata de operadores que forman parte del lenguaje, no
de funciones de biblioteca.

El operador delete libera la memoria asignada previamente por new. No se
debe tratar de liberar memoria previamente liberada o no asignada con new.

Es posible hacer asignaciones de memoria con inicializacin:

int *max= new int ( 1000) ;

Tambin es posible crear arreglos dinmicamente:

char *cad;
- 27 -
cad= new char [ 30] ;
. . .
delete [ ] cad;

Usar delete sin los corchetes para arreglos dinamicos puede no liberar
adecuadamente la memoria, sobre todo si son elementos de un tipo definido por el
usuario.

Ejemplo 1:



int mai n( ) {
int *p, *q;

p= new int; / / asi gna memor i a

if( ! p) {
cout <<" No se pudo asi gnar memor i a\ n" ;
return 0;
}
*p=100;
cout <<endl << *p<<endl ;

q= new int ( 123) ; / / asi gna memor i a
cout <<endl << *q<<endl ;

delete p; / / l i ber a memor i a
/ / *p=20; Uso i ndebi do de p pues ya se l i ber o
/ / cout <<endl << *p<<endl ; l a memor i a
delete q;
return 0;
}

- 28 -
Ejemplo 2:



int mai n( ) {
float *ap, *p=new float ( 3) ;
const int MAX=5;
ap= new float [ MAX] ; / / asi gna memor i a
int i ;
for( i =0; i <MAX; i ++)
ap[ i ] =i * *p;
for( i =0; i <MAX; i ++)
cout <<ap[ i ] <<endl ;
delete p;
delete [ ] ap;
return 0;
}

Ejemplo 3:


typedef struct {
int n1,
n2,
n3;
}cPr ueba;

int mai n( ) {
cPr ueba *pr 1, *pr 2;

pr 1= new cPr ueba;
pr 1- >n1=11;
pr 1- >n2=12;
pr 1- >n3=13;

pr 2= new cPr ueba( *pr 1) ;
- 29 -
delete pr 1;

cout << pr 2- >n1<<" " <<pr 2- >n2 <<" " <<pr 2- >n3<<endl ;

delete pr 2;
return 0;
}

- 30 -
Plantill as

Cuando las operaciones son idnticas pero requieren de diferentes tipos de
datos, podemos usar lo que se conoce como templates o plantillas de funcin.

El trmino de plantilla es porque el cdigo sirve como base (o plantilla) a
diferentes tipos de datos. C++genera al compilar el cdigo objeto de las
funciones para cada tipo de dato involucrado en las llamadas
Las definiciones de plantilla se escriben con la palabra clave template, con una
lista de parmetros formales entre <>. Cada parmetro formal lleva la palabra
clave class.

Cada parmetro formal puede ser usado para sustituir a: tipos de datos bsicos,
estructurados o definidos por el usuario, tipos de los argumentos, tipo de regreso
de la funcin y para variables dentro de la funcin.

Ejemplo 1:



template <class T>
T mayor ( T x, T y)
{
return ( x > y) ? x : y;
};

int mai n( ) {
int a=10, b=20, c=0;
float x=44. 1, y=22. 3, z=0 ;

c=mayor ( a, b) ;
z=mayor ( x, y) ;
cout <<c<<" " <<z<<endl ;

/ / z=mayor ( x, b) ; er r or no hay mayor ( f l oat , i nt )
- 31 -
/ / z=mayor ( a, y) ; " " " " " " " " ( i nt , f l oat )

return 0;
}

Consideraciones:
Cada parmetro formal debe aparecer en la lista de parmetros de la funcin al
menos una vez.
No puede repetirse en la definicin de la plantilla el nombre de un parmetro
formal.
Tener cuidado al manejar mas de un parmetro en los templates.

Ejemplo 2:



template <class T>
void despl egaAr r ( T ar r [ ] , const int cont , T pr )
{
for( int i =0; i <cont ; i ++)
cout << ar r [ i ] << " " ;
cout <<endl ;
cout <<pr <<endl ;
}

int mai n( ) {
const int cont Ent =4, cont Fl ot =5, cont Car =10;
int ent [ ] ={1, 2, 3, 4};
float f l ot [ ] ={1. 1, 2. 2, 3. 3, 4. 4, 5. 5};
char car [ ] ={" Pl ant i l l a" };

cout << " Ar r egl o de f l ot ant es: \ n" ;
despl egaAr r ( f l ot , cont Fl ot , ( float) 3. 33) ;

- 32 -
cout << " Ar r egl o de car act er es: \ n" ;
despl egaAr r ( car , cont Car , ' Z' ) ;

cout << " Ar r egl o de ent er os: \ n" ;
despl egaAr r ( ent , cont Ent , 99) ;

return 0;
}

Ejemplo 3:



template <class T, class TT>
T mayor ( T x, TT y)
{
return ( x > y) ? x : y;
};

int mai n( ) {

int a=10, b=20, c=0;
float x=44. 1, y=22. 3, z=0 ;

c=mayor ( a, b) ;
z=mayor ( x, y) ;

cout <<c<<" " <<z<<endl ;
/ / si n er r or al aument ar un par met r o f or mal .
z=mayor ( x, b) ;
cout <<z<<endl ;
z=mayor ( a, y) ; / / r egr esa ent er o pues a es ent er o ( t i po T es
ent er o par a
cout <<z<<endl ; / / est e l l amado.

z=mayor ( y, a) ;
cout <<z<<endl ;
- 33 -
c=mayor ( y, a) ; / / r egr esa f l ot ant e per o l a asi gnaci n l o
cor t a en ent er o.
cout <<c<<endl ;

return 0;
}

- 34 -
Introduccin a la programacin orientada a objetos [2, 3]

Programaci n no estructurada

Comnmente, las personas empiezan a aprender a programar escribiendo
programas pequeos y sencillos consistentes en un solo programa principal.

Aqu "programa principal" se refiere a una secuencia de comandos o
instrucciones que modifican datos que son a su vez globales en el transcurso de
todo el programa.

Programaci n procedural

Con la programacin procedural se pueden combinar las secuencias de
instrucciones repetitivas en un solo lugar.

Una llamada de procedimiento se utiliza para invocar al procedimiento.

Despus de que la secuencia es procesada, el flujo de control procede
exactamente despus de la posicin donde la llamada fue hecha.

- 35 -
Al introducir parmetros, as como procedimientos de procedimientos
(subprocedimientos) los programas ahora pueden ser escritos en forma ms
estructurada y con menos errores.

Por ejemplo, si un procedimiento ya es correcto, cada vez que es usado
produce resultados correctos. Por consecuencia, en caso de errores, se puede
reducir la bsqueda a aquellos lugares que todava no han sido revisados.

De este modo, un programa puede ser visto como una secuencia de llamadas
a procedimientos. El programa principal es responsable de pasar los datos a las
llamadas individuales, los datos son procesados por los procedimientos y, una vez
que el programa ha terminado, los datos resultantes son presentados.

As, el flujo de datos puede ser ilustrado como una grfica jerrquica, un
rbol, como se muestra en la figura para un programa sin subprocedimientos.

Programaci n modul ar

En la programacin modular, los procedimientos con una funcionalidad comn
son agrupados en mdulos separados.

Un programa por consiguiente, ya no consiste solamente de una seccin. Ahora
est dividido en varias secciones ms pequeas que interactan a travs de
llamadas a procedimientos y que integran el programa en su totalidad.

- 36 -
Cada mdulo puede contener sus propios datos. Esto permite que cada mdulo
maneje un estado interno que es modificado por las llamadas a procedimientos de
ese mdulo.

Sin embargo, solamente hay un estado por mdulo y cada mdulo existe
cuando ms una vez en todo el programa.

Datos y Operaci ones separados

La separacin de datos y operaciones conduce usualmente a una estructura
basada en las operaciones en lugar de en los datos: Los Mdulos agrupan las
operaciones comunes en forma conjunta.

Al programar entonces se usan estas operaciones proveyndoles
explcitamente los datos sobre los cules deben operar.

La estructura de mdulo resultante est por lo tanto orientada a las
operaciones ms que sobre los datos. Se podra decir que las operaciones
definidas especifican los datos que sern usados.

En la programacin orientada a objetos, la estructura se organiza por
los datos. Se escogen las representaciones de datos que mejor se ajusten a tus
- 37 -
requerimientos. Por consecuencia, los programas se estructuran por los datos ms
que por las operaciones.

Los datos especifican las operaciones vlidas. Ahora, los mdulos agrupan
representaciones de datos en forma conjunta.

Programaci n orientada a obj etos

La programacin orientada a objetos resuelve algunos de los problemas que
se acaban de mencionar. De alguna forma se podra decir que obliga a prestar
atencin a los datos.

En contraste con las otras tcnicas, ahora tenemos una telaraa de objetos
interactuantes, cada uno de los cules manteniendo su propio estado.

Por ejemplo, en la programacin orientada a objetos deberamos tener tantos
objetos de pila como sea necesario. En lugar de llamar un procedimiento al que
le debemos proveer el manejador de la pila correcto, mandaramos un mensaje
directamente al objeto pila en cuestin.

- 38 -
En trminos generales, cada objeto implementa su propio mdulo,
permitiendo por ejemplo que coexistan muchas pilas. Cada objeto es responsable
de inicializarse y destruirse en forma correcta.

No es sta solamente una manera ms elegante de tcnica de
programacin modular?

Tipos de Datos Abstractos

Algunos autores describen la programacin orientada a objetos como
programacin de tipos de datos abstractos y sus relaciones. Los tipos de datos
abstractos son como un concepto bsico de orientacin a objetos.

Los Problemas
La primera cosa con la que uno se enfrenta cuando se escriben programas es
el problema.

Tpicamente, uno se enfrenta a problemas "de la vida real" y nos queremos
facilitar la existencia por medio de un programa para manejar dichos problemas.

Sin embargo, los problemas de la vida real son nebulosos y la primera cosa
que se tiene que hacer es tratar de entender el problema para separar los detalles
esenciales de los no esenciales: tratando de obtener tu propia perspectiva
abstracta, o modelo, del problema. Este proceso de modelado se llama abstraccin
y se ilustra en la Figura:

- 39 -

El modelo define una perspectiva abstracta del problema. Esto implica que
el modelo se enfoca solamente en aspectos relacionados con el problema y que
uno trata de definir propiedades del problema. Estas propiedades incluyen

los datos que son afectados
las operaciones que son identificadas

por el problema.

Para resumir, la abstraccin es la estructuracin de un problema nebuloso en
entidades bien definidas por medio de la definicin de sus datos y operaciones.
Consecuentemente, estas entidades combinan datos y operaciones. No estn
desacoplados unos de otras.

Tipos de Datos Abstractos y Orientacin a Objetos

Los TDAs permiten la creacin de instancias con propiedades bien definidas
y comportamiento bien definido. En orientacin a objetos, nos referimos a los
TDAs como clases. Por lo tanto, una clase define las propiedades de objetos en un
ambiente orientado a objetos.

Los TDAs definen la funcionalidad al poner especial nfasis en los datos
involucrados, su estructura, operaciones, as como en axiomas y precondiciones.
- 40 -
Consecuentemente, la programacin orientada a objetos es "programacin con
TDAs: al combinar la funcionalidad de distintos TDAs para resolver un
problema. Por lo tanto, instancias de TDAs son creadas dinmicamente, usadas y
destrudas.

Conceptos de bsicos de objetos

La programacin tradicional separa los datos de las funciones, mientras que
la programacin orientada a objetos define un conjunto de objetos donde se
combina de forma modular los datos con las funciones.

Aspectos principales:

1) Objetos.
El objeto es la entidad bsica del modelo orientado a objetos.
El objeto integra una estructura de datos (atributos) y un comportamiento
(operaciones).
Se distinguen entre s por medio de su propia identidad, aunque internamente
los valores de sus atributos sean iguales.

2) Clasificacin.
Las clases describen posibles objetos, con una estructura y comportamiento
comn.
Los objetos que contienen los mismos atributos y operaciones pertenecen a la
misma clase.
La estructura de clases integra las operaciones con los atributos a los cuales se
aplican.

3) Instanciacin.
El proceso de crear objetos que pertenecen a una clase se denomina
instanciacin.
Pueden ser instanciados un nmero indefinido de objetos de cierta clase.

- 41 -
4) Generalizacin.
En una jerarqua de clases, se comparten atributos y operaciones entre clases
basados en la generalizacin de clases.
La jerarqua de generalizacin se construye mediante la herencia.
Las clases ms generales se conocen como superclases.
Las clases ms especializadas se conocen como subclases. La herencia puede
ser simple o mltiple.

5) Abstraccin.
La abstraccin se concentra en lo primordial de una entidad y no en sus
propiedades secundarias.
Adems en lo que el objeto hace y no en cmo lo hace.
Se da nfasis a cuales son los objetos y no cmo son usados.
6) Encapsulacin.
Encapsulacin o encapsulamiento es la separacin de las propiedades externas
de un objeto de los detalles de implementacin internos del objeto.
Al separar la interfaz del objeto de su implementacin, se limita la complejidad
al mostrarse slo la informacin relevante.
Disminuye el impacto a cambios en la implementacin, ya que los cambios a
las propiedades internas del objeto no afectan su interaccin externa.

7) Modularidad.
El encapsulamiento de los objetos trae como consecuencia una gran
modularidad.
Cada mdulo se concentra en una sola clase de objetos.
Los mdulos tienden a ser pequeos y concisos.
La modularidad facilita encontrar y corregir problemas.
La complejidad del sistema se reduce facilitando su mantenimiento.

8) Extensibilidad.
La extensibilidad permite hacer cambios en el sistema sin afectar lo que ya
existe.
Nuevas clases pueden ser definidas sin tener que cambiar la interfaz del resto
del sistema.
- 42 -
La definicin de los objetos existentes puede ser extendida sin necesidad de
cambios ms all del propio objeto.

9) Polimorfismo.
El polimorfismo es la caracterstica de definir las mismas operaciones con
diferente comportamiento en diferentes clases.
Se permite llamar una operacin sin preocuparse de cul implementacin es
requerida en que clase, siendo responsabilidad de la jerarqua de clases y no
del programador.

10) Reusabilidad de cdigo.
La orientacin a objetos apoya el reuso de cdigo en el sistema.
Los componentes orientados a objetos se pueden utilizar para estructurar
libreras resuables.
El reuso reduce el tamao del sistema durante la creacin y ejecucin.
Al corresponder varios objetos a una misma clase, se guardan los atributos y
operaciones una sola vez por clase, y no por cada objeto.
La herencia es uno de los factores ms importantes contribuyendo al
incremento en el reuso de cdigo dentro de un proyecto.

- 43 -
Lenguajes de programacin orientada a obj etos

Simula I fue originalmente diseado para problemas de simulacin y fue el
primer lenguaje en el cual los datos y procedimientos estaban unificados en una
sola entidad. Su sucesor Simula , deriv definiciones formales a los conceptos de
objetos y clase.

Simula sirvi de base a una generacin de lenguajes de programacin
orientados a objetos. Es el caso de C++, Eiffel y Beta.

Ada (1983), se derivan de conceptos similares, e incorporan el concepto de
jerarqua de herencia. CLU -clusters- tambin incorpora herencia.

Smalltalk es descendiente directo de Simula, generaliza el concepto de
objeto como nica entidad manipulada en los programas. Existen tres versiones
principales: Smalltalk-72, introdujo el paso de mensajes para permitir la
comunicacin entre objetos. Smalltalk-76 que introdujo herencia. Smalltalk-80
se inspira en Lisp.

Lisp contribuy de forma importante a la evolucin de la programacin
orientada a objetos.

Flavors maneja herencia mltiple apoyada con facilidades para la
combinacin de mtodos heredados.

CLOS , es el estndar del sistema de objetos de Common Lisp.

Los programas de programacin orientada a objetos pierden eficiencia ante
los lenguajes imperativos, pues al ser interpretado estos en la arquitectura von
Neumann resulta en un excesivo manejo dinmico de la memoria por la constante
creacin de objetos, as como una fuerte carga por la divisin en mltiples
operaciones (mtodos) y su ocupacin. Sin embargo se gana mucho en
comprensin de cdigo y modelado de los problemas.
- 44 -

Caractersticas de los principales LPOO
1

Ada 95 Eiffel Smalltalk C++ Java
Paquetes S No No No S
Herencia Simple Mltiple Simple Mltiple Simple
Control de tipos Fuerte Fuerte Sin tipos Fuerte Fuerte
Enlace Dinmico Dinmico Dinmico Dinmico Dinmico
Concurrencia S No No No S
Recoleccin de
basura
No S S No S
Afirmaciones No S No No Si
2

Persistencia No No No No No
Generecidad S S S S Si
3

Otra comparacin puede ser vista en la siguiente tabla, tomada de Wikipedia
4
:

Language
General
model of
execution
Influences Paradigm(s)
Typing
discipline
Introduced
Ada Compilation
Algol, Pascal,
C++(Ada 95),
Smalltalk (Ada 95),
J ava (Ada 2005)
concurrent,
distributed,
generic,
imperative,
object-
oriented
static,
strong,
safe,
nominative
1983
C++ Compilation
C, Simula, Algol
68
imperative,
object-
oriented,
static,
strong,
unsafe,
1985

1
Lenguajes de Programacin Orientada a Objetos
2
A partir de la version 5 (1.5) de Java
3
Idem
4
La tabla completa puede ser vista en:
http://en.wikipedia.org/wiki/Comparison_of_programming_languages
- 45 -
generic nominative
C#
J IT
compilation
Delphi, J ava, C++,
Ruby
imperative,
object-
oriented,
generic,
multi-
platform
static,
strong,
both safe
and unsafe
2000
Eiffel Compilation Ada, Simula
imperative,
object-
oriented,
generic
static,
strong,
safe,
nominative,
contracts
1985
Java
Interpretation
/ J IT
compilation
C++, Objective-C,
C#
[2]

imperative,
object-
oriented,
multi-
platform,
generic
static,
strong
1994
Object
Pascal
Compilation Pascal
imperative,
object-
oriented
static,
strong, safe
(but unsafe
allowed),
nominative
1985
Ruby Interpretation Smalltalk,Perl,Lisp
imperative,
object-
oriented,
functional,
aspect-
oriented
dynamic
(duck),
strong
1995
Smalltalk
J IT
compilation
Sketchpad, Simula
object-
oriented,
functional,
concurrent,
event-driven,
imperative,
declarative
dynamic,
strong,
safe, duck
1971

- 46 -

Introduccin a Java
Origen

J ava es un lenguaje de programacin orientada a objetos,
diseado dentro de Sun Microsystems por J ames Gosling.
Originalmente, se le asign el nombre de Oak y fue un lenguaje
pensado para usarse dentro de dispositivos electrodomsticos, que
tuvieran la capacidad de comunicarse entre s.

Posteriormente fue reorientado hacia Internet, aprovechando el auge que
estaba teniendo en ese momento la red, y lo rebautizaron con el nombre de J ava.
Es anunciado al pblico en mayo de 1995 enfocndolo como la solucin para el
desarrollo de aplicaciones en web. Sin embargo, se trata de un lenguaje de
propsito general que puede ser usado para la solucin de problemas diversos.

J ava es un intento serio de resolver simultneamente los problemas
ocasionados por la diversidad y crecimiento de arquitecturas
incompatibles, tanto entre mquinas diferentes como entre los diversos
sistemas operativos y sistemas de ventanas que funcionaban sobre una
misma mquina, aadiendo la dificultad de crear aplicaciones distribuidas
en una red como Internet.

El inters que gener J ava en la industria fue mucho, tal que nunca un
lenguaje de programacin haba sido adoptado tan rpido por la comunidad de
desarrolladores. Las principales razones por las que J ava es aceptado tan rpido:

Aprovecha el inicio del auge de la Internet, especficamente del World
Wide Web.
Es orientado a objetos, la cual si bien no es tan reciente, estaba en uno
de sus mejores momentos, todo mundo quera programar de acuerdo al
modelo de objetos.
- 47 -
Se trataba de un lenguaje que eliminaba algunas de las principales
dificultades del lenguaje C/C++, el cul era uno de los lenguajes
dominantes. Se deca que la ventaja de J ava es que es sintcticamente
parecido a C++, sin serlo realmente.
J ava era resultado de una investigacin con fines comerciales, no era
un lenguaje acadmico como Pascal o creado por un pequeo grupo de
personas como C C++.

Aunado a esto, las caractersticas de diseo de J ava, lo hicieron muy
atractivo a los programadores.

Caractersticas de diseo

Es un lenguaje de programacin de alto nivel, de propsito general, y cuyas
caractersticas son [5]:

Simple y familiar.
Orientado a objetos.
Independiente de la plataforma
Portable
Robusto.
Seguro.
Multihilos.

Simple y familiar

Es simple, ya que tanto la estructura lxica como sintctica del lenguaje es
muy sencilla. Adems, elimina las caractersticas complejas e innecesarias de sus
predecesores.

Es familiar al incorporar las mejores caractersticas de lenguajes tales como:
C/C++, Modula, Beta, CLOS, Dylan, Mesa, Lisp, Smalltalk, Objective-C, y
Modula 3.
- 48 -

Orientado a Objetos

Es realmente un lenguaje orientado a objetos, todo en J ava son objetos:

No es posible que existan funciones que no pertenezcan a una clase.
La excepcin son los tipos da datos primitivos, como nmeros, caracteres y
bolanos
5
.

Cumple con los 4 requerimientos de Wegner [6]:

OO =abstraccin +clasificacin +polimorfismo +herencia
Independiente de la plataforma

La independencia de la plataforma implica que un programa en J ava se
ejecute sin importar el sistema operativo que se este ejecutando en una mquina
en particular. Por ejemplo un programa en C++compilado para Windows, debe
ser al menos vuelto a compilar si se quiere ejecutar en Unix; adems,
posiblemente habr que ajustar el cdigo que tenga que ver con alguna
caracterstica particular de la plataforma, como la interfaz con el usuario.

J ava resuelve el problema de la distribucin binaria mediante un formato de
cdigo binario (bytecode) que es independiente del hardware y del sistema
operativo gracias a su mquina virtual.

Si el sistema de runtime o mquina virtual est disponible para una
plataforma especfica, entonces una aplicacin puede ejecutarse sin necesidad de
un trabajo de programacin adicional.

5
Los puristas objetaran que no es totalmente orientado a objetos. En un sentido estricto Smalltalk es un
lenguaje ms puro, ya que ah hasta los tipos de datos bsicos son considerados objetos.
Hardware
S.O.
Aplicacin
Runtime Java
- 49 -

Portable

Una razn por la que los programas en J ava son portables es precisamente
que el lenguaje es independiente de la plataforma.

Adems, la especificacin de sus tipos de datos primitivos y sus tamaos,
as como el comportamiento de los operadores aritmticos, son estndares en
todas las implementaciones de J ava. Por lo que por ejemplo, un entero es definido
de un tamao de 4 bytes, y este espacio ocupar en cualquier plataforma, por lo
que no tendr problemas en el manejo de los tipos de datos. En cambio, un entero
en C generalmente ocupa 2 bytes, pero en algunas plataformas el entero ocupa 4
bytes, lo que genera problemas a la hora de adaptar un programa de una
plataforma a otra.

Robusto

J ava se considera un lenguaje robusto y confiable, gracias a:

Validacin de tipos. Los objetos de tipos compatibles pueden ser asignados
a otros objetos sin necesidad de modificar sus tipos. Los objetos de tipos
potencialmente incompatibles requieren un modificador de tipo (cast).
Si la modificacin de tipo es claramente imposible, el compilador lo
rechaza y reporta un error en tiempo de compilacin. Si la modificacin
resulta legal, el compilador lo permite, pero inserta una validacin en
tiempo de ejecucin.
Cuando el programa se ejecuta se realiza la validacin cada vez que se
ejecuta una asignacin potencialmente invlida.

Control de acceso a variables y mtodos. Los miembros de una clase
pueden ser privados, pblicos o protegidos
6
.

6
Ms adelante en el curso se ahondar en el tema.
- 50 -
En java una variable privada, es realmente privada. Tanto el
compilador como la mquina virtual de J ava, controlan el acceso a los
miembros de una clase, garantizando as su privacidad.

Validacin del apuntador Null. Todos los programas en J ava usan
apuntadores para referenciar a un objeto. Esto no genera inestabilidad pues
una validacin del apuntador a Null ocurre cada vez que un apuntador deja
de referencia a un objeto. C y C++por ejemplo, no tienen esta
consideracin sobre los apuntadores, por lo que es posible estar
referenciando a localidades invlidas de la memoria.

Limites de un arreglo. J ava verifica en tiempo de ejecucin que un
programa no use arreglos para tratar de acceder a reas de memoria que no
le pertenecen. De nuevo, C y C++no tiene esta verificacin, lo que permite
que un programa se salga del lmite mayor y menor de un arreglo.

Aritmtica de apuntadores. Aunque todos los objetos se manejan con
apuntadores, J ava elimina la mayor parte de los errores de manejo de
apuntadores porque no soporta la aritmtica de apuntadores:

o No soporta acceso directo a los apuntadores
o No permite operaciones sobre apuntadores.

Manejo de memoria. Muchos de los errores de la programacin se deben a
que el programa no libera la memoria que debera liberar, o se libera la
misma memoria ms de una vez.

J ava, hace recoleccin automtica de basura, liberando la memoria y
evitando la necesidad de que el programador se preocupe por liberar
memoria que ya no utilice.

- 51 -
Diferencias entre Java y C++

Se compara mucho al lenguaje de J ava con C++, y esto es lgico debido a la
similitud en la sintaxis de ambos lenguajes, por lo que resulta necesario resaltar
las diferencias principales que existen entre estos. J ava a diferencia de C++:

No tiene aritmtica de apuntadores. J ava si tiene apuntadores, sin
embargo no permite la manipulacin directa de las direcciones de memoria.
No se proporcionan operadores para el manejo de los apuntadores pues no
se considera responsabilidad del programador.

No permite funciones con mbito global. Toda operacin debe estar
asociada a una clase, por lo que el mbito de la funcin esta limitado al
mbito de la clase.

Elimina la instruccin goto. La instruccin goto se considera obsoleta, ya
que es una herencia de la poca de la programacin no estructurada. Sin
embargo, esta definida como palabra reservada para restringir su uso.

Las cadenas no terminan con \0. Las cadenas en C y C++terminan con
\0 que corresponde al valor en ASCII 0, ya que en estos lenguajes no
existe la cadena como un tipo de dato estndar y se construye a partir de
arreglos de caracteres. En J ava una cadena es un objeto de la clase String y
no necesita ese carcter para indicar su finalizacin.

No maneja macros. Una macro es declarada en C y C++a travs de la
instruccin #define, la cual es tratada por el preprocesador.

No soporta un preprocesador. Una de las razones por las cuales no maneja
macros J ava es precisamente porque no tiene un preprocesador que prepare
el programa previo a la compilacin.

El tipo char contiene 16 bits. Un carcter en J ava utiliza 16 bits en lugar
de 8 para poder soportar UNICODE en lugar de ASCII, lo que permite la
representacin de mltiples smbolos.
- 52 -

Java soporta mltiples hilos de ejecucin. Los mltiples hilos de
ejecucin o multihilos permiten un fcil manejo de programacin
concurrente. Otros lenguajes dependen de la plataforma para implementar
concurrencia.

Todas las condiciones en Java deben tener como resultado un tipo
boleano. Dado que en J ava los resultados de las expresiones son dados bajo
este tipo de dato. Mientras que en C y C++se considera a un valor de cero
como falso y no cero como verdadero.

Java no soporta el operador sizeof. Este operador permite en C y C++
obtener el tamao de una estructura de datos. En J ava esto no es necesario
ya que cada objeto sabe el espacio que ocupa en memoria.

No tiene herencia mltiple. J ava solo cuenta con herencia simple, con lo
que pierde ciertas capacidades de generalizacin que son subsanadas a
travs del uso de interfaces. El equipo de desarrollo de J ava explica que esto
simplifica el lenguaje y evita la ambigedad natural generada por la
herencia mltiple.

No tiene liberacin de memoria explcita (delete y free() ). En J ava no es
necesario liberar la memoria ocupada, ya que cuenta con un recolector de
basura
7
responsable de ir liberando cada determinado tiempo los recursos de
memoria que ya no se estn ocupando.

Adems:

No contiene estructuras y uniones (struct y union).
No contiene tipos de datos sin signo.
No permite alias (typedef).
No tiene conversin automtica de tipos compatibles.

7
Garbage Collector.
- 53 -

Archi vos .j ava y .cl ass

En J ava el cdigo fuente se almacena en archivos con extensin .java,
mientras que el bytecode o cdigo compilado se almacena en archivos .class. El
compilador de J ava crea un archivo .class por cada declaracin de clase que
encuentra en el archivo .java.

Un archivo de cdigo fuente debe tener solo una clase principal, y esta debe
tener exactamente el mismo nombre que el del archivo .java. Por ejemplo, si
tengo una clase que se llama Alumno, el archivo de cdigo fuente se llamar
Alumno.java. Al compilar, el archivo resultante ser Alumno.class.

Programas generados con j ava

Existen dos tipos principales de programas en J ava
8
:

Por un lado estn las aplicaciones, las cuales son programas standalone,
escritos en J ava y ejecutados por un intrprete del cdigo de bytes desde la lnea
de comandos del sistema.

Por otra parte, los Applets, que son pequeas aplicaciones escritas en J ava,
las cuales siguen un conjunto de convenciones que les permiten ejecutarse dentro
de un navegador. Estos applets siempre estn incrustados en una pgina html.

En trminos del cdigo fuente las diferencias entre un applet y una
aplicacin son:

Una aplicacin debe definir una clase que contenga el mtodo main(),
que controla su ejecucin. Un applet no usa el mtodo main(); su

8
Se presenta la divisin clsica de los programas de Java, aunque existen algunas otras opciones no son
relevantes en este curso.
- 54 -
ejecucin es controlado por varios mtodos definidos en la clase
applet.

Un applet, debe definir una clase derivada de la clase Applet.

El Java Devel opers Ki t

La herramienta bsica para empezar a desarrollar aplicaciones o applets en
J ava es el J DK (Java Development Kit) o Kit de Desarrollo J ava, que consiste,
bsicamente, en un compilador y un intrprete (J VM
9
) para la lnea de comandos.
No dispone de un entorno de desarrollo integrado (IDE), pero es suficiente para
aprender el lenguaje y desarrollar pequeas aplicaciones.
10

Los principales programas del Java Development Kit:

javac. Es el compilador en lnea del J DK.

java. Es la mquina virtual para aplicaciones de J ava.

appletviewer. Visor de applets de java.

Compilacin

Utilizando el J DK, los programas se compilan desde el smbolo del sistema
con el compilador javac.

Ejemplo:

C: \ Mi sPr ogr amas> j avac Mi Cl ase. j ava

9
Java Virtual Machine
10
Este kit de desarrollo es gratuito y puede obtenerse de la direccin proporcionada al final de este
documento. Aunque en este curso se usara Eclipse, el jdk debe estar instalado para poder usar Java en
Eclipse.
- 55 -

Normalmente se compila como se ha mostrado en el ejemplo anterior. Sin
embargo, el compilador proporciona diversas opciones a travs de modificadores
que se agregan en la lnea de comandos.

Sintaxis:

j avac [ opci ones] <ar chi vo1. j ava>

donde opciones puede ser:

- cl asspat h <r ut a> Indica donde buscar los archivos de clasede J ava
- d <di r ect or i o> Indica el directorio destino para los archivos .class
- g Habilita la generacin de tablas de depuracin.
- nowar n Deshabilita los mensajes del compilador.
- O Optimiza el cdigo, generando en lnea los mtodos
estticos, finales y privados.
- ver bose Indica cul archivo fuente se esta compilando.
- 56 -
Hol a Mundo

Para no ir en contra de la tradicin al comenzar a utilizar un lenguaje, los
primeros ejemplos sern precisamente dos programas muy simples que lo nico
que van a hacer es desplegar el mensaje Hola Mundo.

Hola mundo bsico en J ava

El primero es una aplicacin que va a ser interpretado posteriormente por la
mquina virtual:

public class Hol aMundo {
public static void mai n( St r i ng ar gs[ ] ) {
Syst em. out. pr i nt l n( " Hol a, Mundo! " ) ;
}
}

Para los que han programado en C C++, notarn ya ciertas similitudes. Lo
importante aqu es que una aplicacin siempre requiere de un mtodo main, este
tiene un solo argumento (String args[ ]), a travs del cual recibe informacin de
los argumentos de la lnea de comandos, pero la diferencia con los lenguajes
C/C++es que este mtodo depende de una clase, en este caso la clase
HolaMundo. Este programa es compilado en al jdk
11
:

%j avac Hol aMundo. j ava

con lo que, si el programa no manda errores, se obtendr el archivo
HolaMundo.class.

11
Se asume que el jdk se encuentra instalado y que el PATH tiene indicado el directorio bin del jdk para que
encuentre el programa javac. Tambin es recomendable aadir nuestro directorio de programas de java a una
variable de ambiente llamada CLASSPATH.
- 57 -
En Eclipse, al grabar automticamente el programa se compilara (si la
opcion Build Automatically esta activada). De hecho, algunos errores se van
notificando, si los hay, conforme se va escribiendo el codigo en el editor.

Hola mundo bsico en C++

En C++no estamos obligados a usar clases, por lo que un Hola mundo en
C++- aunque no en objetos podra quedar de la siguiente forma:



int mai n( ) {
cout << " Hol a Mundo! " << endl ;
return 0;
}

Hola mundo en un J ava Applet

Regresando a J ava, veamos ahora la contraparte de este programa, que es el
applet Hola, el cual difiere sustancialmente del programa pasado:

import j ava. appl et . Appl et ;
import j ava. awt . Gr aphi cs;
import j ava. awt . Col or ;

public class Hol a extends Appl et {
public void pai nt ( Gr aphi cs g) { / / J ava l l ama a pai nt
aut omt i cament e
g. set Col or ( Col or . red) ;
g. dr awSt r i ng( " Hol a, Mundo! " , 0, 50) ;
}
}

- 58 -
Este programa tiene diferentes requerimientos a una aplicacin. En principio
carece de un mtodo main, y en su lugar cuenta con un mtodo paint el cual es
llamado por el navegador que cargue la pgina que contenga al applet.

Otro aspecto interesante es el uso de la instruccin import. Las clases en
J ava estn organizadas en paquetes, y son similares a las libreras de C++para
agrupar funciones. Puede utilizarse opcionalmente la instruccin import, o hacer
referencia a toda la ruta completa cada vez que se usa una clase:

j ava. ut i l . Hasht abl e mi Tabl a = new j ava. ut i l . Hast abl e( ) ;

es equivalente a:

import j ava. ut i l . Hasht abl e; / / i mpor t ar est a cl ase
. . .
Hasht abl e mi Tabl e = new Hasht abl e( ) ;

Existen algunas clases que no necesitan ser importadas, como la clase
System, estas son las que se encuentran dentro del paquete java.lang, pues son
importadas automticamente para todo programa de J ava.

Tambin es posible importar todas las clases de un paquete mediante el uso
del *. Ejemplo:

import j ava. awt . *;

La compilacin del applet se realiza de la misma forma que con la
aplicacin. Una vez que se tiene el archivo de clase, en el jdk no es posible
todava ejecutar nuestro applet. Hay que preparar un archivo html para que haga
referencia al applet. La creacin del archivo html es no necesaria para ejecutar el
applet desde Eclipse.

- 59 -
Archivo HTML

Anteriormente se mencion que un applet debe ser invocado desde una
pgina de html. Slo es necesario agregar la etiqueta <APPPLET>para indicar el
archivo de bytecode del applet.

Ejemplo de etiqueta en html:

<APPLET CODE=Hol a. cl ass WI DTH=250 HEI GHT=300></ APPLET>

donde es especificado el nombre de la clase y, el ancho y alto que va a
ocupar para desplegarse el applet dentro de la pgina html. La ubicacin del
applet depender de la ubicacin de la etiqueta dentro de la pgina.

Ejecucin

Para ejecutar una aplicacin usamos la mquina virtual proporcionada por el
jdk, proporcionando el nombre de la clase:

%j ava Hol aMundo

Para la ejecucin de un applet utilizamos el appletviewer, tambin
proporcionado por el jdk:

%appl et vi ewer hol a. ht ml

La ejecucin del applet desde Eclipse implica seleccionar la opcion de Run
as y posteriormente Java Applet del men o icono de ejecucin, o del men
contextual.

Un applet en realidad es construido para se ejecutado por un navegador. El
appletviewer es una versin reducida de un navegador que es utilizada para
probar los applets. Un vez que vean que su applet se ejecuta en el visor de applets
prubenlo en su navegador Firefox Explorer.

- 60 -
Es recomendable que primero prueben los applets en el visor, ya que este
soporta la misma versin de J ava del jdk que tengan instalado. Dependiendo de su
configuraron, los navegadores no siempre soportan la ltima versin de J ava.

Hola mundo en Eclipse

Probar estos ejemplos en Eclipse debe crearse un proyecto en J ava. Como en J ava
no hay funciones independientes, los archivos que se aaden al proyecto son
archivos de clases. Al aadir una clase al proyecto aparece la siguiente ventana:

La informacin mnima necesaria es el nombre de la clase. La extensin del
archivo (.java) ser colocada por Eclipse.
- 61 -
Fundamentos del Lenguaje Java

En esta seccin se hablara de cmo est constituido el lenguaje, sus
instrucciones, tipos de datos, etc. Antes de comenzar a hacer programacin
orientada a objetos.

Comentarios

Los comentarios en los programas fuente son muy importantes en cualquier
lenguaje. Sirven para aumentar la facilidad de comprensin del cdigo y para
recordar ciertas cosas sobre el mismo. Son porciones del programa fuente que el
compilador omite, y, por tanto, no ocuparn espacio en el archivo de clase.

Existen tres tipos de comentarios en J ava:

Si el comentario que se desea escribir es de una sola lnea, basta con poner
dos barras inclinadas //. Por ejemplo:

for ( i =0; i <20; i ++) / / coment ar i o de ci cl o
{
Syst em. out . pr i nt l n( Adi s) ;
}

No puede ponerse cdigo despus de un comentario introducido por // en la
misma lnea, ya que desde la aparicin de las dos barras inclinadas // hasta el final
de la lnea es considerado como comentario e ignorado por el compilador.

Si un comentario debe ocupar ms de una lnea, hay que anteponerle /* y al
final */. Por ejemplo:

/ * Est o es un
coment ar i o que
ocupa t r es l neas */

- 62 -
Existe otro tipo de comentario que sirve para generar documentacin
automticamente en formato HTML mediante la herramienta javadoc.
Puede ocupar varias lneas y se inicia con /** para terminar con */. Para
mas informacin ver: http://java.sun.com/j2se/javadoc/

Tipos de datos

En J ava existen dos tipos principales de datos:

1. Tipos de datos simples.
2. Referencias a objetos.

Los tipos de datos simples son aquellos que pueden utilizarse directamente
en un programa, sin necesidad del uso de clases. Estos tipos son:

byte
short
int
long
float
double
char
boolean

El segundo tipo est formado por todos los dems. Se les llama referencias
porque en realidad lo que se almacena en los mismos son punteros a reas de
memoria donde se encuentran almacenadas las estructuras de datos que los
soportan. Dentro de este grupo se encuentran las clases (objetos) y tambin se
incluyen las interfaces, los vectores y las cadenas o Strings.

Pueden realizarse conversiones entre los distintos tipos de datos (incluso
entre simples y referenciales), bien de forma implcita o de forma explcita.

- 63 -
Tipos de datos simples

Los tipos de datos simples en J ava tienen las siguientes caractersticas:

TIPO Descripcin Formato long. Rango
byte byte C-2
12
1 byte - 128 127
short entero corto C-2 2
bytes
- 32.768 32.767
int entero C-2 4
bytes
- 2.147.483.648
2.147.483.647
long entero largo C-2 8
bytes
-9.223.372.036.854.775.808
9.223.372.036.854.775.807
float real en coma
flotante de
precisin
simple
IEEE
754
32
bits
3,4*10-38 3,4*1038
double real en coma
flotante de
precisin
doble
IEEE
754
64
bits
1,7*10-308 1,7*10308
char Carcter Unicode 2
bytes
0 65.535
boolean Lgico 1 bit true / false

No existen ms datos simples en J ava. Incluso stos que se enumeran
pueden ser remplazados por clases equivalentes (Integer, Double, Byte, etc.), con
la ventaja de que es posible tratarlos como si fueran objetos en lugar de datos
simples.

A diferencia de otros lenguajes de programacin como C, en J ava los tipos
de datos simples no dependen de la plataforma ni del sistema operativo. Un

12
C-2 =Complemento a dos.
- 64 -
entero de tipo int siempre tendr 4 bytes, por lo que no tendremos resultados
inesperados al migrar un programa de un sistema operativo a otro.

Eso s, J ava no realiza una comprobacin de los rangos. Por ejemplo: si a
una variable de tipo short con el valor 32.767 se le suma 1, el resultado ser -
32.768 y no se producir ningn error de ejecucin.

Los valores que pueden asignarse a variables y que pueden ser utilizados en
expresiones directamente reciben el nombre de literales.

Referencias a objetos

El resto de tipos de datos que no son simples, son considerados referencias.
Estos tipos son bsicamente apuntadores a las instancias de las clases, en las que
se basa la programacin orientada a objetos.

Al declarar un objeto perteneciente a una determinada clase, se indica que
ese identificador de referencia tiene la capacidad de apuntar a un objeto del tipo al
que pertenece la variable. El momento en el que se realiza la reserva fsica del
espacio de memoria es cuando se instancia el objeto realizando la llamada a su
constructor, y no en el momento de la declaracin.

Existe un tipo referencial especial nominado por la palabra reservada null
que puede ser asignado a cualquier variable de cualquier clase y que indica que el
puntero no tiene referencia a ninguna zona de memoria (el objeto no est
inicializado).

Identifi cadores

Los identificadores son los nombres que se les da a las variables, clases,
interfaces, atributos y mtodos de un programa.

Existen algunas reglas bsicas para nombrar a los identificadores:
- 65 -

1. J ava hace distincin entre maysculas y minsculas, por lo tanto, nombres o
identificadores como var1, Var1 y VAR1 son distintos.
2. Pueden estar formados por cualquiera de los caracteres del cdigo Unicode,
por lo tanto, se pueden declarar variables con el nombre: aoDeCreacin,
ram, etc.
3. El primer carcter no puede ser un dgito numrico y no pueden utilizarse
espacios en blanco ni smbolos coincidentes con operadores.
4. No puede ser una palabra reservada del lenguaje ni los valores lgicos true
o false.
5. No pueden ser iguales a otro identificador declarado en el mismo mbito.
6. Por convencin, los nombres de las variables y los mtodos deberan
empezar por una letra minscula y los de las clases por mayscula.

Adems, si el identificador est formado por varias palabras, la primera se
escribe en minsculas (excepto para las clases e interfaces) y el resto de palabras
se hace empezar por mayscula (por ejemplo: aoDeCreacin). Las constantes se
escriben en maysculas, por ejemplo MXIMO.

Esta ltima regla no es obligatoria, pero es conveniente ya que ayuda al
proceso de codificacin de un programa, as como a su legibilidad. Es ms
sencillo distinguir entre clases y mtodos, variables o constantes.

Variables

La declaracin de una variable se realiza de la misma forma que en C/C++.
Siempre contiene el nombre (identificador de la variable) y el tipo de dato al que
pertenece. El mbito de la variable depende de la localizacin en el programa
donde es declarada.

Ejemplo:

int x;

- 66 -
Las variables pueden ser inicializadas en el momento de su declaracin,
siempre que el valor que se les asigne coincida con el tipo de dato de la variable.
Ejemplo:

int x = 0;

mbito de una variable.

El mbito de una variable es la porcin de programa donde dicha variable es
visible para el cdigo del programa y, por tanto, referenciable. El mbito de una
variable depende del lugar del programa donde es declarada, pudiendo pertenecer
a cuatro categoras distintas.

Variable local.
Atributo.
Parmetro de un mtodo.
Parmetro de un manejador de excepciones
13
.

Como puede observarse, no existen las variables globales. La utilizacin de
variables globales es considerada peligrosa, ya que podra ser modificada en
cualquier parte del programa y por cualquier procedimiento. A la hora de
utilizarlas hay que buscar dnde estn declaradas para conocerlas y dnde son
modificadas para evitar sorpresas en los valores que pueden contener.

Los mbitos de las variables u objetos en J ava siguen los criterios
clsicos, al igual que en la mayora de los lenguajes de programacin como
Pascal, C++, etc.

Si una variable que no es local no ha sido inicializada, tiene un valor
asignado por defecto. Este valor es, para las variables referencias a objetos, el
valor null. Para las variables de tipo numrico, el valor por defecto es cero, las
variables de tipo char, el valor \u0000 y las variables de tipo boolean, el valor
false.

13
Este se tocar en otra etapa del curso, al hablar de manejo de excepciones.
- 67 -

Variables locales. Una variable local se declara dentro del cuerpo de un mtodo
de una clase y es visible nicamente dentro de dicho mtodo. Se puede declarar
en cualquier lugar del cuerpo, incluso despus de instrucciones ejecutables,
aunque es una buena costumbre declararlas justo al principio.

Ejemplo:

class Car act er {
char ch;
public Car act er ( char c) {
ch=c;
}

public void r epet i r ( int num) {
int i ;
for ( i =0; i <num; i ++)
Syst em. out. pr i nt l n( ch) ;
}
}

public class Ej 1 {
public static void mai n( St r i ng ar gument os[ ] ) {
Car act er car act er ;
car act er = new Car act er ( ' H' ) ;
car act er . r epet i r ( 20) ;
}
}

En este ejemplo existe una variable local: int i ; definida en el mtodo
repetir de la clase Caracter, por lo tanto, nicamente es visible dentro del mtodo
repetir. Tambin existe una variable local en el mtodo main. En este caso, la
variable local es un objeto: Car act er car act er ; que slo ser visible
dentro del mtodo en el que est declarada (main).

Es importante hacer notar que una declaracin como la anterior le indica al
compilador el tipo de la variable caracter pero no crea un objeto )la variable es
inicializada con el valor null). El operador que crea el objeto es new, que necesita
- 68 -
como nico parmetro el nombre del constructor, que ser el procedimiento que
asigna valor a ese objeto recin instanciado.

Cuando se pretende declarar mltiples variables del mismo tipo pueden
declararse, en forma de lista, separadas por comas:

Ejemplo:

int x, y, z; / / Decl ar a t r es var i abl es x, y, z de t i po ent er o.

Podran haberse inicializado en su declaracin de la forma:

int x=0, y=0, z=3;

No es necesario que se declaren al principio del mtodo. Puede hacerse en
cualquier lugar del mismo, incluso de la siguiente forma:

void r epet i r ( int num) {
for ( int i =0; i <num; i ++)
Syst em. out. pr i nt l n( ch) ;
}

Las variables locales pueden ser antecedidas por la palabra reservada final.
En ese caso, slo permiten que se les asigne un valor una nica vez
14
.

Ejemplo:

final int x=0;

No permitir que a x se le asigne ningn otro valor. Siempre contendr 0.
No es necesario que el valor se le asigne en el momento de la declaracin, podra
haberse asignado en cualquier otro lugar, pero una sola vez
15
.

14
final es utilizado para declarar algo similar a las constantes.
15
Esta posibilidad aparece por primera vez en la versin 1.1 del jdk.
- 69 -
Ejemplo:

final int x;
. . .
x=y+2;

Despus de la asignacin x=y+2, no se permitir asignar ningn otro valor a
x.

Operadores

Los operadores son partes indispensables en la construccin de expresiones.
Existen muchas definiciones tcnicas para el trmino expresin. Puede decirse
que una expresin es una combinacin de operandos ligados mediante
operadores.

Los operandos pueden ser variables, constantes, funciones, literales, etc. y
los operadores se comentarn a continuacin.

Operadores aritmticos:

Operador Formato Descripcin
+ op1 +op2 Suma aritmtica de dos operandos
- op1 - op2 Resta aritmtica de dos operandos
-op1 Cambio de signo
* op1 * op2 Multiplicacin de dos operandos
/ op1 / op2 Divisin entera de dos operandos
% op1 % op2 Resto de la divisin entera ( o mdulo)
++ ++op1
op1++ Incremento unitario
-- -- op1
op1-- Decremento unitario

- 70 -
El operador - puede utilizarse en su versin unaria ( - op1 ) y la operacin
que realiza es la de invertir el signo del operando.

Como en C/C++, los operadores unarios ++y -- realizan un incremento y un
decremento respectivamente. Estos operadores admiten notacin prefija y
postfija.

++op1: En primer lugar realiza un incremento (en una unidad) de op1 y
despus ejecuta la instruccin en la cual est inmerso.
op1++: En primer lugar ejecuta la instruccin en la cual est inmerso y
despus realiza un incremento (en una unidad) de op1.
- - op1: En primer lugar realiza un decremento (en una unidad) de op1 y
despus ejecuta la instruccin en la cul est inmerso. Visin General y
elementos bsicos del lenguaje.
op1- - : En primer lugar ejecuta la instruccin en la cual est inmerso y
despus realiza un decremento (en una unidad) de op1.

La diferencia entre la notacin prefija y la postfija no tiene importancia en
expresiones en las que nicamente existe dicha operacin:

++cont ador ; / / es equi val ent e a: cont ador ++;
- - cont ador ; / / cont ador - - ;

La diferencia es apreciable en instrucciones en las cules estn incluidas
otras operaciones.

Ejemplo:

a = 1; a = 1;
b = 2 + a++; b = 2 + ++a;

En el primer caso, despus de las operaciones, b tendr el valor 3 y al valor
2. En el segundo caso, despus de las operaciones, b tendr el valor 4 y al valor 2.

- 71 -
Operadores relacionales:

> op1 > op2
Devuelve true si op1 es mayor que
op2
< op1 < op2
Devuelve true si op1 es menor que
op2
>= op1 >= op2
Devuelve true si op1 es mayor o
igual que op2
<= op1<= op2
Devuelve true si op1 es menor o
igual que op2
== op1 == op2
Devuelve true si op1 es igual a op2
! = op1 ! = op2
Devuelve true si op1 es distinto de
op2

Los operadores relacionales actan sobre valores enteros, reales y
caracteres; y devuelven un valor del tipo boleano (true o false).

Ejemplo:

public class Rel aci onal {
public static void mai n( St r i ng ar g[ ] ) {
double op1, op2;
op1=1. 34;
op2=1. 35;
Syst em. out. pr i nt l n( " op1=" +op1+" op2=" +op2) ;
Syst em. out. pr i nt l n( " op1>op2 = " +( op1>op2) ) ;
Syst em. out. pr i nt l n( " op1<op2 = " +( op1<op2) ) ;
Syst em. out. pr i nt l n( " op1==op2 = " +( op1==op2) ) ;
Syst em. out. pr i nt l n( " op1! =op2 = " +( op1! =op2) ) ;
char op3, op4;
op3=' a' ; op4=' b' ;
Syst em. out. pr i nt l n( " ' a' >' b' = " +( op3>op4) ) ;
}
}

- 72 -
Operadores lgicos:

&& op1 && op2
Y lgico. Devuelve true si son ciertos op1 y
op2
| | op1 | | op2
O lgico. Devuelve true si son ciertos op1 o
op2
! ! op1
Negacin lgica. Devuelve true si es falso
op1.

Estos operadores actan sobre operadores o expresiones lgicas, es decir,
aquellos que se evalan a cierto o falso.

Ejemplo:

public class Bool {
public static void mai n ( St r i ng ar gument os[ ] ) {
boolean a=true;
boolean b=true;
boolean c=false;
boolean d=false;
Syst em. out. pr i nt l n( " t r ue Y t r ue = " + ( a && b) ) ;
Syst em. out. pr i nt l n( " t r ue Y f al se = " + ( a && c) ) ;
Syst em. out. pr i nt l n( " f al se Y f al se = " + ( c && d) ) ;
Syst em. out. pr i nt l n( " t r ue O t r ue = " + ( a | | b) ) ;
Syst em. out. pr i nt l n( " t r ue O f al se = " + ( a | | c) ) ;
Syst em. out. pr i nt l n( " f al se O f al se = " + ( c | | d) ) ;
Syst em. out. pr i nt l n( " NO t r ue = " + ! a) ;
Syst em. out. pr i nt l n( " NO f al se = " + ! c) ;
Syst em. out. pr i nt l n( " ( 3 > 4) Y t r ue = " + ( ( 3 >4) && a)
) ;
}
}

- 73 -
Operadores de bits:

>> op1 >> op2
Desplaza op1, op2 bits a la derecha
<< op1 << op2
Desplaza op1, op2 bits a la izquierda
>>> op1 >>> op2
Desplaza op1, op2 bits a la derecha (sin signo).
& op1 & op2
Realiza un Y (AND) a nivel de bits
| op1 | op2
Realiza un O (OR) a nivel de bits
^ op1 ^ op2
Realiza un O exclusivo (XOR) a nivel de bits
~ ~op1
Realiza el complemento de op1 a nivel de bits.

Los operadores de bits actan sobre valores enteros (byte, short, int y long)
o caracteres (char).

Ejemplo:

public class Bi t s {
byte a=12;
byte b=- 12;
byte c=6;
Syst em. out. pr i nt l n( " 12 >> 2 = " + ( a >> 2) ) ;
Syst em. out. pr i nt l n( " - 12 >> 2 = " + ( b >> 2) ) ;
Syst em. out. pr i nt l n( " - 12 >>> 2 = " + ( b >>> 2) ) ;
Syst em. out. pr i nt l n( " 12 << 2 = " + ( a << 2) ) ;
Syst em. out. pr i nt l n( " - 12 << 2 = " + ( b << 2) ) ;
Syst em. out. pr i nt l n( " 12 & 6 = " + ( a & c) ) ;
Syst em. out. pr i nt l n( " 12 | 6 = " + ( a | c) ) ;
Syst em. out. pr i nt l n( " 12 ^ 6 = " + ( a ^ c) ) ;
Syst em. out. pr i nt l n( " ~12 = " + ~a) ;
}
}

Los nmeros negativos se almacenan en Complemento a dos (c-2), lo que
significa que para almacenar el nmero negativo se toma el positivo en binario, se
cambian unos por ceros y viceversa, y despus se le suma 1 en binario.

- 74 -
Operadores de asignacin:

El operador de asignacin es el smbolo igual ( =).

op1 = Expr esi n;

Asigna el resultado de evaluar la expresin de la derecha a op1.

Adems del operador de asignacin existen unas abreviaturas, como en
C/C++, cuando el operando que aparece a la izquierda del smbolo de asignacin
tambin aparece a la derecha del mismo:

Operador Formato Equivalencia
+= op1 += op2 op1 = op1 + op2
- = op1 - = op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/ = op1 / = op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 %op2
&= op1 &= op2 op1 = op1 & op2
| = op1 | = op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
>>= op1 >>= op2 op1 = op1 >> op2
<<= op1 <<= op2 op1 = op1 << op2
>>>= op1 >>>= op2 op1 = op1 >>> op2

Precedencia de operadores en J ava

La precedencia indica el orden en que es resuelta una expresin, la siguiente
lista muestra primero los operadores de mayor precedencia.

Operadores postfijos
[ ] . ( par nt esi s)
Operadores unarios
++expr - - expr - expr ~ !
Creacin o conversin de tipo
new ( t i po) expr
Multiplicacin y divisin
* / %
- 75 -
Suma y resta
+ -
Desplazamiento de bits
<< >> >>>
Relacionales
< > <= >=
Igualdad y desigualdad
== ! =
AND a nivel de bits
&
XOR a nivel de bits
^
OR a nivel de bits
|
AND lgico
&&
OR lgico
| |
Condicional terciaria
? :
Asignacin
= += - = *= / = %= ^= &= | = >>= <<=
>>>=

Valores li terales

A la hora de tratar con valores de los tipos de datos simples (y Strings) se
utiliza lo que se denomina literales. Los literales son elementos que sirven para
representar un valor en el cdigo fuente del programa.

En J ava existen literales para los siguientes tipos de datos:

Lgicos (boolean).
Carcter (char).
Enteros (byte, short, int y long).
Reales (double y float).
Cadenas de caracteres (String).

Literales lgicos

Son nicamente dos: las palabras reservadas true y false.

- 76 -

Ejemplo:

boolean act i vado = false;
Literales de tipo entero

Son byte, short, int y long pueden expresarse en decimal (base 10), octal
(base 8) o hexadecimal (base 16). Adems, puede aadirse al final del mismo la
letra L para indicar que el entero es considerado como long (64 bits).

Literales de tipo real

Los literales de tipo real sirven para indicar valores float o double. A
diferencia de los literales de tipo entero, no pueden expresarse en octal o
hexadecimal.

Existen dos formatos de representacin: mediante su parte entera, el punto
decimal ( . ) y la parte fraccionaria; o mediante notacin exponencial o cientfica:

Ejemplos equivalentes:

3. 1415
0. 31415e1
. 31415e1
0. 031415E+2
. 031415e2
314. 15e- 2
31415E- 4

Al igual que los literales que representan enteros, se puede poner una letra
como sufijo. Esta letra puede ser una F o una D (mayscula o minscula
indistintamente).

F Trata el literal como de tipo float.
D Trata el literal como de tipo double.
- 77 -

Ejemplo:

3. 1415F
. 031415d

Literales de tipo carcter

Los literales de tipo carcter se representan siempre entre comillas simples.
Entre las comillas simples puede aparecer:

Un smbolo (letra) siempre que el carcter est asociado a un cdigo
Unicode. Ejemplos: a , B , { , , .

Una secuencia de escape. Las secuencias de escape son combinaciones
del smbolo \ seguido de una letra, y sirven para representar caracteres que
no tienen una equivalencia en forma de smbolo.

Las posibles secuencias de escape son:

Secuencia de escape Significado
\ Comilla simple.
\ Comillas dobles.
\ \ Barra invertida.
\ b Backspace (Borrar hacia atrs).
\ n Cambio de lnea.
\ f Form feed.
\ r Retorno de carro.
\ t Tabulador.

- 78 -
Literales de tipo String

Los Strings o cadenas de caracteres no forman parte de los tipos de datos
elementales en J ava, sino que son instanciados a partir de la clase
java.lang.String, pero aceptan su inicializacin a partir de literales de este tipo.

Un literal de tipo String va encerrado entre comillas dobles ( ) y debe estar
incluido completamente en una sola lnea del programa fuente (no puede dividirse
en varias lneas). Entre las comillas dobles puede incluirse cualquier carcter del
cdigo Unicode (o su cdigo precedido del carcter \ ) adems de las secuencias
de escape vistas anteriormente en los literales de tipo carcter. As, por ejemplo,
para incluir un cambio de lnea dentro de un literal de tipo String deber hacerse
mediante la secuencia de escape \n :

Ejemplo:

Syst em. out . pr i nt l n( " Pr i mer a l nea \ n Segunda l nea del
st r i ng\ n" ) ;
Syst em. out . pr i nt l n( " Hol \ u0061" ) ;

La visualizacin del String anterior mediante println() producira la siguiente
salida por pantalla:

Pr i mer a l nea
Segunda l nea del st r i ng
Hol a

La forma de incluir los caracteres: comillas dobles ( ) y barra invertida ( \ )
es mediante las secuencias de escape \ y \\ respectivamente (o mediante su
cdigo Unicode precedido de \ ).

Si la cadena es demasiado larga y debe dividirse en varias lneas en el
cdigo fuente, o simplemente concatenar varias cadenas, puede utilizarse el
operador de concatenacin de strings +.de la siguiente forma:

- 79 -
Est e St r i ng es demasi ado l ar go par a est ar en una l nea +
del cdi go f uent e y se ha di vi di do en dos.

Estructuras de control

Las estructuras de control son construcciones definidas a partir de palabras
reservadas del lenguaje que permiten modificar el flujo de ejecucin de un
programa. De este modo, pueden crearse construcciones de decisin y ciclos de
repeticin de bloques de instrucciones.

Hay que sealar que, como en C/C++, un bloque de instrucciones se
encontrar encerrado mediante llaves {..} si existe ms de una instruccin.

Estructuras condicionales

Las estructuras condicionales o de decisin son construcciones que permiten
alterar el flujo secuencial de un programa, de forma que en funcin de una
condicin o el valor de una expresin, el mismo pueda ser desviado en una u otra
alternativa de cdigo.

Las estructuras condicionales disponibles en J ava son:

Estructura if-else.
Estructura switch.

if-else

Forma simple:

if ( <expr esi n>)
<Bl oque i nst r ucci ones>

El bloque de instrucciones se ejecuta si, y slo si, la expresin (que debe ser
lgica) se evala a verdadero, es decir, se cumple una determinada condicin.
- 80 -

Ejemplo:

if ( cont == 0)
Syst em. out . pr i nt l n( " he l l egado a cer o" ) ;

La instruccin Syst em. out . pr i nt l n( he l l egado a cer o) ; slo se
ejecuta en el caso de que cont contenga el valor cero.

Forma bicondicional:

if ( <expr esi n>)
<Bl oque i nst r ucci ones 1>
else
<Bl oque i nst r ucci ones 2>

El bloque de instrucciones 1 se ejecuta si, y slo si, la expresin se evala
como verdadero. Y en caso contrario, si la expresin se evala como falso, se
ejecuta el bloque de instrucciones 2.

Ejemplo:

if ( cont == 0)
Syst em. out . pr i nt l n( " he l l egado a cer o" ) ;
else
Syst em. out . pr i nt l n( " no he l l egado a cer o" ) ;

En J ava, como en C/C++y a diferencia de otros lenguajes de programacin,
en el caso de que el bloque de instrucciones conste de una sola instruccin no
necesita ser encerrado en un bloque.

switch

Sintaxis:

switch ( <expr esi n>) {
case <val or 1>: ;
- 81 -
. . .
case <val or N>: ;
}

En este caso, a diferencia del if, si <instrucciones1>, <instrucciones2>
<instruccionesN> estn formados por un bloque de instrucciones sencillas, no es
necesario encerrarlas mediante las llaves ( { } ).

En primer lugar se evala la expresin cuyo resultado puede ser un valor de
cualquier tipo. El programa comprueba el primer valor (valor1). En el caso de que
el valor resultado de la expresin coincida con valor1, se ejecutar el bloque
<instrucciones1>. Pero tambin se ejecutaran el bloque <instrucciones2>
<instruccionesN> hasta encontrarse con la palabra reservada break. Por lo que
comnmente se aade una instruccin break al final de cada caso del switch.

Ejemplo:

switch ( <expr esi n>) {

break;
break;
. . .
case <val or N>: ;
}

Si el resultado de la expresin no coincide con <valor1>, evidentemente no
se ejecutaran <instrucciones1>, se comprobara la coincidencia con <valor2>y
as sucesivamente hasta encontrar un valor que coincida o llegar al final de la
construccin switch. En caso de que no exista ningn valor que coincida con el de
la expresin, no se ejecuta ninguna accin.

- 82 -
Ejemplo:

public class Di aSemana {
int di a;
if ( ar gument os. l engt h<1) {
Syst em. out. pr i nt l n( " Uso: Di aSemana num" ) ;
Syst em. out. pr i nt l n( " Donde num= n ent r e 1 y 7" ) ;
}
else {
di a=I nt eger . valueOf( ar gument os[ 0] ) . i nt Val ue( ) ;
switch ( di a) {
case 1: Syst em. out. pr i nt l n( " Lunes" ) ;
break;
case 2: Syst em. out. pr i nt l n( " Mar t es" ) ;
break;
case 3: Syst em. out. pr i nt l n( " Mi r col es" ) ;
break;
case 4: Syst em. out. pr i nt l n( " J ueves" ) ;
break;
case 5: Syst em. out. pr i nt l n( " Vi er nes" ) ;
break;
case 6: Syst em. out. pr i nt l n( " Sbado" ) ;
break;
case 7: Syst em. out. pr i nt l n( " Domi ngo" ) ;
}
}
}
}

Ntese que en el caso de que se introduzca un valor no comprendido entre 1 y 7,
no se realizar ninguna accin. Esto puede corregirse agregando la opcin por
omisin:

default: i nst r ucci onesPor Def ect o;

donde la palabra reservada default, sustituye a case <expr> para ejecutar el
conjunto de instrucciones definido en caso de que no coincida con ningn otro
caso.
- 83 -

Ciclos.

Los ciclos o iteraciones son estructuras de repeticin. Bloques de
instrucciones que se repiten un nmero de veces mientras se cumpla una
condicin o hasta que se cumpla una condicin.

Existen tres construcciones para estas estructuras de repeticin:

Ciclo for.
Ciclo do-while.
Ciclo while.

Como regla general puede decirse que se utilizar el ciclo for cuando se
conozca de antemano el nmero exacto de veces que ha de repetirse un
determinado bloque de instrucciones. Se utilizar el ciclo do-while cuando no se
conoce exactamente el nmero de veces que se ejecutar el ciclo pero se sabe que
por lo menos se ha de ejecutar una. Se utilizar el ciclo while cuando es posible
que no deba ejecutarse ninguna vez. Con mayor o menor esfuerzo, puede
utilizarse cualquiera de ellas indistintamente.

Ciclo for.

Sintaxis:

for ( ; <condi ci n> ; )
<bl oque i nst r ucci ones>

La clusula inicializacin es una instruccin que se ejecuta una sola vez al
inicio del ciclo, normalmente para inicializar un contador.
La clusula condicin es una expresin lgica, que se evala al inicio de
cada nueva iteracin del ciclo. En el momento en que dicha expresin se
evale a falso, se dejar de ejecutar el ciclo y el control del programa pasar
a la siguiente instruccin (a continuacin del ciclo for).
- 84 -
La clusula incremento es una instruccin que se ejecuta en cada iteracin
del ciclo como si fuera la ltima instruccin dentro del bloque de
instrucciones. Generalmente se trata de una instruccin de incremento o
decremento de alguna variable.

Cualquiera de estas tres clusulas puede estar vaca, aunque siempre hay que
poner los puntos y coma ( ; ).

El siguiente programa muestra en pantalla la serie de Fibonacci hasta el
trmino que se indique al programa como argumento en la lnea de comandos.
Siempre se mostrarn, por lo menos, los dos primeros trminos

Ejemplo:

/ / si empr e se most r ar n, por l o menos, l os dos pr i mer os
/ / t r mi nos
public class Fi bonacci {
int numTer m, v1=1, v2=1, aux, cont ;
Syst em. out. pr i nt l n( " Uso: Fi bonacci num" ) ;
Syst em. out. pr i nt l n( " Donde num= n de t r mi nos" ) ;
}
else {
numTer m=I nt eger . valueOf( ar gument os[ 0] ) . i nt Val ue( ) ;
Syst em. out. pr i nt ( " 1, 1" ) ;
for ( cont =2; cont <numTer m; cont ++) {
aux=v2;
v2+=v1;
v1=aux;
Syst em. out. pr i nt ( " , " +v2) ;
}
Syst em. out. pr i nt l n( ) ;
}
}
}

- 85 -
Ciclo do-while.

Sintaxis:

do
while ( <Expr esi n>) ;

En este tipo de ciclo, el bloque instrucciones se ejecuta siempre una vez por
lo menos, y el bloque de instrucciones se ejecutar mientras <Expr esi n> se
evale como verdadero. Por lo tanto, entre las instrucciones que se repiten deber
existir alguna que, en algn momento, haga que la expresin se evale como
falso, de lo contrario el ciclo sera infinito.

Ejemplo:

/ / El mi smo que ant es ( Fi bonacci ) .
class Fi bonacci 2 {
int numTer m, v1=0, v2=1, aux, cont =1;
}
else {
Syst em. out. pr i nt ( " 1" ) ;
do {
aux=v2;
v2+=v1;
v1=aux;
} while ( ++cont <numTer m) ;
}
}
}

- 86 -
En este caso nicamente se muestra el primer trmino de la serie antes de
iniciar el ciclo, ya que el segundo siempre se mostrar, porque el ciclo do-while
siempre se ejecuta una vez por lo menos.

Ciclo while.

Sintaxis:

while ( <Expr esi n>)

Al igual que en el ciclo do-while del apartado anterior, el bloque de
instrucciones se ejecuta mientras se cumple una condicin (mientras Expresin se
evale verdadero), pero en este caso, la condicin se comprueba antes de empezar
a ejecutar por primera vez el ciclo, por lo que si Expresin se evala como falso
en la primera iteracin, entonces el bloque de instrucciones no se ejecutar
ninguna vez.

Ejemplo:

/ / Fi bonacci :
class Fi bonacci 3 {
int numTer m, v1=1, v2=1, aux, cont =2;
}
else {
Syst em. out. pr i nt ( " 1, 1" ) ;
while ( cont ++<numTer m) {
aux=v2;
v2+=v1;
v1=aux;
- 87 -
}
}
}
}

Como puede comprobarse, las tres construcciones de ciclo (for, do-while y
while) pueden utilizarse indistintamente realizando unas pequeas variaciones en
el programa.

Saltos

En J ava existen dos formas de realizar un salto incondicional en el flujo
normal de un programa: las instrucciones break y continue.

break. La instruccin break sirve para abandonar una estructura de control, tanto
de las alternativas (if-else y switch) como de las repetitivas o ciclos (for, do-while
y while). En el momento que se ejecuta la instruccin break, el control del
programa sale de la estructura en la que se encuentra.

Ejemplo:

class Br eak {
int i ;
for ( i =1; i <=4; i ++) {
if ( i ==3)
break;
Syst em. out. pr i nt l n( " I t er aci on: " +i ) ;
}
}
}

Aunque el ciclo, en principio indica que se ejecute 4 veces, en la tercera
iteracin, i contiene el valor 3, se cumple la condicin de i==3 y por lo tanto se
ejecuta el break y se sale del ciclo for.
- 88 -

continue. La instruccin continue sirve para transferir el control del programa
desde la instruccin continue directamente a la cabecera del ciclo (for, do-while o
while) donde se encuentra.

Ejemplo:

public class Cont i nue {
int i ;
for ( i =1; i <=4; i ++) {
if ( i ==3)
continue;
Syst em. out. pr i nt l n( " I t er eaci n: " +i ) ;
}
}
}

Puede comprobarse la diferencia con respecto al resultado del ejemplo del
apartado anterior. En este caso no se abandona el ciclo, sino que se transfiere el
control a la cabecera del ciclo donde se contina con la siguiente iteracin.

Tanto el salto break como en el salto continue, pueden ser evitados
mediante distintas construcciones pero en ocasiones esto puede empeorar la
legibilidad del cdigo. De todas formas existen programadores que no aceptan
este tipo de saltos y no los utilizan en ningn caso; la razn es que - se dice - que
atenta contra las normas de las estructuras de control.

Arreglos

Para manejar colecciones de objetos del mismo tipo estructurados en una
sola variable se utilizan los arreglos.

En J ava, los arreglos son en realidad objetos y por lo tanto se puede llamar a
sus mtodos. Existen dos formas equivalentes de declarar arreglos en J ava:

- 89 -
t i po nombr eDel Ar r egl o[ ] ;

t i po[ ] nombr eDel Ar r egl o;

Ejemplo:

int ar r egl o1[ ] , ar r egl o2[ ] , ent er o; / / ent er o no es un ar r egl o
int[ ] ot r oAr r egl o;

Tambin pueden utilizarse arreglos de ms de una dimensin:

Ejemplo:

int mat r i z[ ] [ ] ;
int [ ] [ ] ot r aMat r i z;

Los arreglos, al igual que las dems variables pueden ser inicializados en el
momento de su declaracin. En este caso, no es necesario especificar el nmero
de elementos mximo reservado. Se reserva el espacio justo para almacenar los
elementos aadidos en la declaracin.

Ejemplo:

St r i ng D as[ ] ={" Lunes" , " Mar t es" , " Mi r col es" , " J ueves" ,
" Vi er nes" , " Sbado" , " Domi ngo" };

Una simple declaracin de un vector no reserva espacio en memoria, a
excepcin del caso anterior, en el que sus elementos obtienen la memoria
necesaria para ser almacenados. Para reservar la memoria hay que llamar
explcitamente a new de la siguiente forma:

new t i poEl ement o[ <numEl ement os> ] ;

Ejemplo:

int mat r i z[ ] [ ] ;
mat r i z = new int[ 4] [ 7] ;
- 90 -

Tambin se puede indicar el nmero de elementos durante su declaracin:

Ejemplo:

int vect or [ ] = new int[ 5] ;

Para hacer referencia a los elementos particulares del arreglo, se utiliza el
identificador del arreglo junto con el ndice del elemento entre corchetes. El
ndice del primer elemento es el cero y el del ltimo, el nmero de elementos
menos uno.

Ejemplo:

j = vect or [ 0] ; vect or [ 4] = mat r i z[ 2] [ 3] ;

El intento de acceder a un elemento fuera del rango del arreglo, a diferencia
de lo que ocurre en C, provoca una excepcin (error) que, de no ser manejado por
el programa, ser la mquina virtual quien aborte la operacin.

Para obtener el nmero de elementos de un arreglo en tiempo de ejecucin
se accede al atributo de la clase llamado length. No olvidemos que los arreglos en
J ava son tratados como un objeto.

Ejemplo:

class Ar r ay1 {
St r i ng col or es[ ] = {" Roj o" , " Ver de" , " Azul " ,
" Amar i l l o" , " Negr o" };
int i ;
for ( i =0; i <col or es. l engt h; i ++)
Syst em. out. pr i nt l n( col or es[ i ] ) ;
}
}

- 91 -
Usando J ava 5.0 (jdk 1.5) podemos simplificar el recorrido del arreglo:

public class Meses {

public static void mai n( St r i ng[ ] ar gs) {
St r i ng meses[ ] =
{" Ener o" , " Febr er o" , " Mar zo" , " Abr i l " , " Mayo" ,
" J uni o" , " J ul i o" , " Agost o" , " Sept i embr e" , " Oct ubr e" ,
" Novi embr e" , " Di ci embr e" };

/ / f or ( i nt i = 0; i < meses. l engt h; i ++ )
/ / Syst em. out . pr i nt l n( " mes: " + meses[ i ] ) ;

/ / si nt axi s par a r ecor r er el ar r egl o y asi gnar
/ / el si gui ent e el ement o a l a var i abl e mes en cada
ci cl o
/ / i nst r ucci on " f or each" a par t i r de ver si on 5. 0 ( 1. 5
del j dk)
for( St r i ng mes: meses)
Syst em. out. pr i nt l n( " mes: " + mes) ;

}

}

Con Eclipse, aparte de contar al menos con el jdk 1.5, la opcin de compilacin
debe estar ajustada para que revise que el cdigo sea compatible con esa versin:

- 92 -

Enumeraci ones

J ava desde la versin 5 incluye el manejo de enumeraciones. Las enumeraciones
sirven para agrupar un conjunto de elementos dentro de un tipo definido. Antes,
una manera simple de definir un conjunto de elementos como si fuera una
enumeracin era, por ejemplo:

public static final int TEMPO_PRI MAVERA = 0;
public static final int TEMPO_VERANO = 1;
public static final int TEMPO_OTOO = 2;
public static final int TEMPO_I NVI ERNO = 3;

Lo cual puede ser problemtico pues no es realmente un tipo de dato, sino un
conjunto de constantes enteras. Tampoco tienen un espacio de nombres definido
por lo que tienen que definirse nombre. La impresin de estos datos, puesto que
son enteros, despliega solo el valor numrico a menos que sea interpretado
explcitamente por cdigo adicional en el programa.

El manejo de enumeraciones en J ava tiene la sintaxis de C, C++y C#:

enum <nombr eEnum> { <elem 1>, <elem 2>, , <elem n> }

Por lo que para el cdigo anterior, la enumeracin sera:

enum Tempor ada { PRIMAVERA, VERANO, OTOO, INVIERNO }

La sintaxis completa de enum es ms compleja, ya que una enumeracin en J ava
es realmente una clase, por lo que puede tener mtodos en su definicin. Tambin
es posible declarar la enumeracin como pblica, en cuyo caso debera ser
declarada en su propio archivo.

- 93 -

Ejemplo:

enum Tempor ada { PRIMAVERA, VERANO, OTOO, INVIERNO }

public class EnumEj {

Tempor ada t em;
t em=Tempor ada. PRIMAVERA;
Syst em. out. pr i nt l n( " Tempor ada: " + t em) ;

Syst em. out. pr i nt l n( " \ nLi st ado de t empor adas: " ) ;

for( Tempor ada t : Tempor ada. values( ) )
Syst em. out. pr i nt l n( " Tempor ada: " + t ) ;

}
}

- 94 -

Introduccin a Ruby

Ruby es un lenguaje definido para ser dinmico, reflectivo y orientado a objetos.
Combina una sintaxis inspirada en Perl y similar a las caractersitcas orientadas a
objetos de Smalltalk. Tambin comparte ciertas caractersticas con Phyton, Lisp,
Dylan, y CLU.

Ruby fue creado por Yukihiro Matsumoto con la idea de
crear un lenguaje que balanceara la programacin funcional
con la programacin imperativa.

El lenguaje fue liberado desde un inicio como open source
(1995) y en los ltimos aos ha crecido su aceptacin
masivamente.

Matsumoto dice haber puesto nfasis en crear un lenguaje
productivo y divertido, siguiendo los principios de buen
dise de interfaz con el usuario. Remarka que el diseo de
sistemas necesita tambin- enfatizar las necesidades
humanas, en lugar de las de la computadora.

Ruby es actualmente un lenguaje interpretado aunque se pretende que a partir de
la versin 1.9 sea semi-compilado y ejecutado por una mquina virtual, de
manera similar a J ava.

Caractersticas

Ruby es principalmente un lenguaje orientado a objetos, pero tambin
es descrito como un lenguaje multiparadigma: permite programacin
procedural, con orientacin a objetos y declaraciones funcionales.

- 95 -
Un resumen de sus caractersticas puede verse enseguida:
Orientado a objetos
4 niveles de alcance de variables: global, clase, instancia y local
Manejo de exepciones
Expresiones regulares nativas al nivel del lenguaje (perl-like)
Sobrecarga de operadores
Recolector automtico de basura
Biblioteca dinmica compartida en la mayora de las plataformas
Soporta introspeccin, reflexin y metaprogramacin
Soporta continuations y generators

Comparado con C

Similitudes
Puedes programar proceduralmente si lo deseas, pero an sera orientado a
objetos internamente.
La mayora de los operadores son los mismos. Pero no cuenta con ++o --.
Se pueden tener constantes, aunque no hay una instruccin const.
Las cadenas van entre comillas y son mutables.
Se cuenta con un depurador en lnea.

Diferencias
Los objetos tienen un tipo fuerte y las variables no tienen tipo.
No cuenta con macros o preprocesador.
No tiene enmascaramiento.
No tiene apuntadores, ni aritmtica de apuntadores.
No tiene tupedef, sizeof, ni enumeraciones.
No archivos de encabezados.
No maneja #define. Pero puedas usar constantes.
Es interpretado en tiempo de ejecucin, por lo que no hay cdigo compilado
o byt-code de ningn tipo.
Cuenta con recolector de basura.
Los argumentos son pasados por referencia, no por valor.
No usa ; obligatoriamente para finalizar instrucciones
- 96 -
Condiciones para if y while van sin parntesis.
Parntesis para llamadas a mtodos son frecuentemente opcionales.
Usualmente no se usan llaves. Usualmente se finalizan las instrucciones de
multiples lneas con una palabra clave.
No hay declaraciones de variables. Asignas nombre conforme los necesitas.
Slo falso y nulo evaluan como falso. Cualquier otro valor es verdadero
(incluyendo 0 cero-)
No hay tipo char.
Cadenas no terminan con un valor nulo.
Los arreglos automticamente se agrandan conforme vas necesitando ms
elementos.
Comparado con C++

Similitudes
Public, protected y private realizan actividades similares.
Puedes poner tu cdigo en mdulos, similar a espacios de nombre en C++.
Excepciones trabajan de forma similar.

Diferencias
No hay referencias explcitas. En Ruby cada variable es un nombre
automticamente desreferenciado para un objeto.
El constructor es llamado initialize en lugar de usar el nombre de la clase.
Todos los mtodos son siempre virtuales.
Nombres de atributos de clase siempre empiezan con @@.
No es possible acceder directamente variables miembros. Todos los
atributos deben ser accedidos a mediante mtodos.
Se usa self en lugar de this.
Algunos mtodos terminan con ? o !. Es parte del nombre del mtodo.
No hay herencia multiple.
Existen algunas convenciones forzadas (e.g.; nombre de clases empiezan
con mayscula, variables inician con minuscula.)
Solo dos tipos de clases contenedoras: Array y Hash.
No hay conversiones de tipos automticas.
- 97 -
Multihilos son implementados en el interprete (green threads). No son hilos
nativos.
Existe una biblioteca para pruebas de unidad como parte estndar del
lenguaje.
Comparado con J ava

Similitudes
La memoria es manejada automticamente mediante un recolector de
basura.
Los objetos son fuertemente tipados.
Hay mtodos pblicos, privados y protegidos.
Tiene herramientas de documentacin embebidas (la de Ruby se llama
RDoc). La documentacin generada por rdoc se ve muy similar a la
generada por javadoc.

Diferencias
No necesitas compilar tu cdigo fuente. Directamente lo ejecutas.
Hay distintos conjuntos de herramientas para interfaz grfica
Se usa la palabra clave end despus de definir clases, en vez de tener que
poner llaves encerrando el cdigo.
Tienes require en vez de import.
Todas las variables de instancia son privadas. Desde afuera, todo se accede
usando mtodos.
Los parntesis en las llamadas a los mtodos usualmente son opcionales y a
menudo son omitidos.
Todo es un objeto, incluyendo los nmeros como 2 y 3,14159.
No hay validacin esttica de tipos de datos.
Los nombres de variables son slo etiquetas. No tienen un tipo de dato
asociado.
No hay declaracin de tipo de datos. Simplemente se asigna a nuevos
nombres de variable a medida que se necesita (por ejemplo a =[1,2,3] en
vez de int[] a ={1,2,3};).
- 98 -
No hay transformacin de tipos (casting). Simplemente se llama a los
mtodos. Tus pruebas unitarias deberan avisarte antes de que ejecutes el
cdigo si habr una excepcin.
Es foo = Foo.new("hola") en vez de Foo foo = new Foo("hola").
El constructor siempre se llama initialize en vez del nombre de la clase.
Tienes mixins en vez de interfaces.
Se tiende a favorecer el uso de YAML en vez de XML.
Es nil en vez de null.
Herramientas

Existen dos herramientas bsicas en Ruby:

ruby. Es el interprete del lenguaje. Puede recibir expresiones del lenguaje
como parmetros o archivos con programas:
irb (o fxri en Windows). Este es Ruby interactivo (Interactive RuBy) que
permite recibir expresiones del lenguaje e irlas interpretando linea por linea,
como cualquier lenguaje interpretado.
Adems:
ri. Documentacin de clases estndar de ruby.

Tambin es posible integrar al interprete al IDE de Eclipse. Para esto se debe
agregar el plugin llamado Ruby Development Tools (RDT) aparte de tener
instalado el interprete en la computadora. El plugin puede ser encontrado en:
http://rubyeclipse.sourceforge.net/. Tiene que agregarse, como cualquier otro
plugin en la herramienta, mediante la opcin de actualizacin del software en el
menu de ayuda de Eclipse.

El plugin debe configurarse indicando la ubicacin del intrprete:

- 99 -

Ruby: Fundamentos del lenguaje
Convenciones lxi cas

Espacios en blanco

Mientras una expresin del tipo a +b es interpretada como a+b, donde a es
una variable. El resultado puede ser diferente en casos ambiguos. Por ejemplo, si
a es el nombre de una funcin, entonces una expresin:

a +b

es interpretada como:

a (+b)
- 100 -

Final de instrucciones

Ruby interpreta ; y el espacio en blanco como el final de una instruccin.
Debido a esto, Ruby interpreta los smbolos +, - y \ como contianuacin de
una instruccin.

Comentarios

Comentarios en Ruby son representados con #

#Este es un comentario

Comentarios de ms de una lnea usan =begin y =end, los cuales deben estar al
comienzo de una lnea:

=begin
Este es un comentatio
=end

Identificadores

Cualquier nombre de constante, variables y mtodos usado como identificador es
distinguido por Ruby si usa minsculas o maysculas.

Literales

Enteros

Los nmeros enteros son instancias de la clase Fixnum o Bignum.

123 # deci mal
0377 # oct al
- 101 -
0xf f # hexadeci mal
0b1011 # bi nar y
?a # cdi go par a ' a'
12345678901234567890 # Bi gnum: ent er o de l ongi t ud
i nf i ni t a

Flotantes

Los nmeros de punto flotante son instancias de la clase Float.

123. 4
1. 0e6 # not aci n ci ent f i ca
4e+20 # exponenci al

Cadenas
Una cadena es un arreglo de bytes y una instancia de la clase String:

una cadena #permite sustitucin y notacin con \

otra cadena #no permite sustitucin y solo \ \ \.

Concatenacin.

Cadenas adyacentes son concatenadas :
una cadena #es igual a una cadena

Variables

En Ruby existen 5 tipos de variables, usando caracteres especiales para
diferenciar entre los distintos tipos de variables, lo que ayuda a identificar el tipo
de variable visualmente:

Variable global
- 102 -
Variable de instancia
Variable de clase
Variable local
Constante

y adems:

Pseudo-variable

Variable global

Visibles a travs de todo el programa y deben iniciar con el smbolo $, por
ejemplo:

$soyGlobal

Una variable global no inicializada tiene el valor de nil. Existen adems
variables globales predefinidas que contienen informacin sobre el programa en
ejecucin.

Variable de instancia

Las variables de instancia pertenecen a un objeto y son lo que tambin es
conocido en objetos como atributos. Estas son visibles dentro de un objeto en
particular y deben comenzar con @, por ejemplo:

@soyVariableDeInstancia

Al igual que las variables globales, estas tienen el valor de nil si no han sido
inicializadas.

Variable de clase

Las variables de clase son visibles, como su nombre lo dice, en la clase y
para todos los objetos de la misma. Comienzan con @@, por ejemplo:
- 103 -

@@variableDeClase

Estas variables deben ser inicializadas antes de que puedan ser usadas en los
mtodos. El uso de una variable de clase no inicializada produce un error.
Ademas, estas clases son compartidas por descendientes de las clases donde
fueron definidas.

Variable local

Son vlidas dentro del ambito local definido y deben empezar con una
minscula o con el smbolo _. El mbito puede ser el que defina una clase,
mdulo, definicin, do end.

Constante

Deben empezar con una letra mayscula y pueden ser definidas dentro de
una clase o mdulo y sern visibles dentro de ese mbito. Una constante
definida fuera de un clase o mdulo ser vista globalmente. Es posible reasignar
un valor a una constante, pero esto producir una advertencia (pero no un error).

Pseudo-variable

Pseudo-variables tienen la apariencia de variables locales pero su
comportamiento es el de constantes. Ejemplo de estas vriables son self, true,
false, nil.

Operadores

Asignacin

La asignacin funcion con el operador =. Asignar variables locales tambin sirve
como declaracin de la variable. La viariable existe hasta el final del alcance
donde la variable es declarada.
- 104 -

Tambin se cuenta con asignacin abreviada como en los lenguajes C/C++y
J ava:

+= -= *= /= %= **= <<= >>= &= |= ^= &&= ||=

Asignacin paralela

destino[, destino...][, *destino] =expr[, expr...][, *expr]

Identificadores destino recibenla asignacin de la correspondiente expresin en el
lado derecho. Si el ltimo destino (lado izquierdo) tiene como prefijo un *, el
resto de los valores en el lado derecho se asigna en ese destino como un arreglo.
Si el * esta en el ltimo elemento del lado derecho, el conjunto de elementos son
expandidos antes de su asignacin.

Operadores lgicos

&& and. Regresa true si ambos operandos son verdaderos. Si el operando
izquierdo es falso, regresa ese valor, en caso contrario regresa el valor del
operando derecho.

|| or. Regresa true si cualquiera de los operandos es verdadero. Si el valor del
opreando izquierdo es true, regresa el valor de ese operando, de otro modo
regresa el valor del operando derecho.

Un aspecto interesante aqu es que los operadores and y or tienen una precedencia
muy baja, de hecho tienen la menor de las precedencias entre los operadores.

Operador ternario

El operador ternario ?: es el operador condicional similar al de C/C++y J ava.

a? b : c
- 105 -

Operador defined?

Este es un operador que puede determinar si una expressin esta definida.
Regresa una descripcin de la expresin, o nulo si la expresin no esta definida.

defined? variable

Por ejemplo:

defined? a
defined? $_

Puede ser usado para verificar una llamada a un mtodo, opcionalmente
incluyendo sus argumentos.

Prioridad de operadores

A continuacin se presenta los operadores ms comunes de Ruby en orden de
precedencia, de mayor a menor:

::
[]
**
+(unario) -(unario)
* / %
+-
<<>>
&
| ^
>>=<<=
<=>== !=
&&
||
- 106 -
?:
=(y operadores abreviados como +=, -=, etc.)
not
and or

Operadores que no pueden ser redefinidos

Los siguientes operadores no pueden ser redefinidos :

...
!
not
&&
and
||
or
::
=
+=, -=, (y el resto de las asignaciones abreviadas)
? :

Arreglos

Un arreglo en Ruby es una clase contenedora que contiene una coleccin de
objetos. Cualquier tipo de objetos pueden ser almacenados en un arreglo,
inclusive pudiendo contener elementos de distinto tipo en un mismo arreglo. Otra
caracterstica es que el arreglo aumenta de tamao conforme se aaden elementos.
Un arreglo es representado con sus elementos entre corchetes [ ] :

[ ] Arreglo vaco

[1, 2, 3] Arreglo de 3 elementos

- 107 -
Los arreglos pueden ser asignados:

ar1=[]

ar2=[1, 2, 3] #=>[1, 2, 3]

Un arreglo puede aadir fcilmente un elemento mediante el operador <<. Ruby
dinmicamente ajusta el tamao del arreglo al aadir o remover los elementos:

ar3= ar2 <<otro #=>[1, 2, 3, "otro"]

El operador <<modifica el operando izquierdo, por lo que la modificacin de un
arreglo puede hacerse directamente como:

ar3<<"otro mas" #=>[1, 2, 3, "otro", "otro mas"]

De hecho en la penltima expresin ar3 en realidad est recibiendo la referencia
de ar2 al cual se le aadi la cadena otro.

Como en C++y J ava, en Ruby el ndice de un arreglo comienza con cero.

a =[1, 2, 3, [4, 5, 6]] #=>[1, 2, 3, [4, 5, 6]]
a[0] #=>1

El mtodo size puede ser utilizado para conocer el nmero de elementos del
arreglo:

a.size #=>4
a[3] #=>[4, 5, 6]
a[3].size #=>3
a[3][0] #=>4

El tamao del arreglo es validado:
a[5] #=>nil

- 108 -
Es posible hacer uso de valores negativos como ndices, y estos se tomaran de la
ltima posicin (-1) hasta la posicin negativa del tamao del arreglo (tambin
posicin 0:

a[-1] #=>[4, 5, 6]
a[a.size*-1] #=>1

- 109 -

Probando Ruby

Porque no empezar a probar ruby siguiendo el tutorial el lnea? ste se encuentra
disponible en : http://tryruby.hobix.com/

- 110 -

Estructuras de control

Condicional if. Se ejecuta si la condicin es verdadera.

Sintaxis:

i f condi ci onal [ t hen]
i nst r ucci ones
[ el si f condi ci onal [ t hen]
i nst r ucci ones] . . .
[ el se
i nst r ucci ones]
end

El if puede ser usado como un modificador de una declaracin:

code i f condi ci onal

Ejemplos:

i f x < 5 t hen
decl ar aci on1
end

i f x < 5 t hen
decl ar aci on1
el se
decl ar aci on2
end

decl ar aci on1 i f y == 3

x = i f a>0 t hen b el se c end

- 111 -
Condicional unless. Ejecuta cdigo si la condicin es falsa, en caso contrario
ejecuta otro bloque de instrucciones.

Sintaxis:

unl ess condi ci onal [ t hen]
i nst r ucci ones
[ el se
i nst r ucci ones]
end

El unless puede ser usado como un modificador de una declaracin:

i nst r ucci ones i f condi ci onal

Ejemplos:

unl ess x >= 5 t hen
decl ar aci on1
end

unl ess x < 5 t hen
decl ar aci on1
el se
decl ar aci on2
end

decl ar aci on1 unl ess y ! = 3

x = unl ess a<=0 t hen c el se b end

Case. Compara la expresin especificada en case con la expresin especificada en
when y ejecuta el cdigo correspondiente. La clausula else se ejecuta en el caso
de que ningn segmento when sea ejecutado.

- 112 -
Sintaxis:

case expr esi n
[ when expr esi n[ , expr esi n. . . ] [ t hen]
i nst r ucci ones] . . .
[ el se
i nst r ucci ones]
end

Ejemplo:

case " Una cadena. "
when " al gun val or "
put s " opci on 1"
when " ot r o val or "
put s " opci on 2"
when / char /
put s " opci on 3"
el se
put s " opci on 4"
end

Ciclo while. Se ejecuta el conjunto de instrucciones mientras la condicin es
verdadera. La condicin puede ser separada del conjunto de instrucciones
mediante la palabra reservada do, una lnea nueva, el smbolo \, o un ;.

Sintaxis:

whi l e condi ci onal [ do]
i nst r ucci ones
end

El while puede ser usado como un modificador de una declaracin:

i nst r ucci ones whi l e condi ci onal

:

- 113 -
begi n
i nst r ucci ones
end whi l e condi ci onal

Ejecuta instrucciones mientras la condicin es verdadera. En el caso del entre las
clausulas begin y end, este se ejecuta una vez antes de evaluar la condicin.

Ciclo until. El ciclo until se ejecuta el conjunto de instrucciones mientras la
condicin es falsa (hasta que la condicin se cumpla). Puede ser separada del
cdigo por la palabra reservada do, un salto de lnea o un ;. De igual forma que
el while, until puede ser usado como modificador de una declaracin.

Sintaxis:

unt i l condi ci onal [ do]
i nst r ucci ones
end

:

i nst r ucci ones unt i l condi ci onal

:

begi n
i nst r ucci ones
end unt i l condi ci onal

Ciclo for. Ejecuta el conjunto de instrucciones por cada elemento en la
expresin. La expresin en el for puede ir separada por la palabra reservada do,
un salto de lnea, o un ;.

Sintaxis:

- 114 -
f or var i abl e[ , var i abl e. . . ] i n expr esi on [ do]
i nst r ucci ones
end

Instrucciones break, next, redo.

break. Termina un ciclo while o until. Tambin finaliza un mtodo con un bloque
asociado si es usado dentro del bloque, con el mtodo regresando el valor de nulo.

next. Salta al punto en que se evala la condicin de un ciclo. Tambin termina la
ejecucin de un bloque si es llamado dentro de ste.

redo. Salta al punto inmediatamente posterior a la evaluacin del ciclo.

Instrucciones BEGIN y END.

BEGIN. Permite declarar un conjunto de instrucciones a ejecutarse antes de que el
programa se ejecute.

BEGI N {
i nst r ucci ones
}

END. Permite declarar un conjunto de instrucciones a ejecutarse antes de finalizar
la ejecucin del interprete.

END {
i nst r ucci ones
}

Algunos ejemplos:

# Ci cl o 1 ( whi l e)
i =0
- 115 -
whi l e i < l i st . si ze do
pr i nt " #{l i st [ i ] } "
i += 1
end

# Ci cl o 2 ( unt i l )
i =0
unt i l i == l i st . si ze do
pr i nt " #{l i st [ i ] } "
i += 1
end

# Ci cl o 3 ( f or )
f or x i n l i st do
pr i nt " #{x} "
end

# Ci cl o 4 ( l oop)
i =0
n=l i st . si ze- 1
l oop do
pr i nt " #{l i st [ i ] } "
i += 1
br eak i f i > n
end

# Ci cl o 6 ( l oop)
i =0
n=l i st . si ze- 1
l oop do
pr i nt " #{l i st [ i ] } "
i += 1
br eak unl ess i <= n
end

# Ci cl o 7 ( f or )
n=l i st . si ze- 1
- 116 -
f or
i i n 0. . n do
pr i nt " #{l i st [ i ] } "
end

---
car = "Pat r i ot "

manuf act ur er = case car
when "Focus": " For d"
when "Navi gat or ": " Li ncol n"
when "Camr y": " Toyot a"
when "Ci vi c": " Honda"
when "Pat r i ot ": " J eep"
when "J et t a": " VW"
when "Ceyene" : "Por sche"
when "Out back": " Subar u"
when "520i " : "BMW"
when "Tundr a" : "Ni ssan"
el se "Desconoci do"
end

put s " El " + car + " es f abr i cado por " + manuf act ur er

- -

cal i f = 70

r esul t = case scor e
when 0. . 59: " Repr obado"
when 61. . 70: "Apr obadoapenas"
when 71. . 80: "Apr obado"
when 81. . 100: " Excel ent e"
el se "Resul t ado i nvl i do"
end

put s r esul t

- -
- 117 -

f or j i n 1. . 5 do
f or i i n 1. . 5 do
pr i nt i , " "
end
put s
end

- -
f or i i n 1. . 8 do
put s i
end
- -
- 118 -
Entrada y Salida bsica en Ruby

Ruby proporciona instrucciones bsicas de entrada y salida. Para Desplegar en la
consola, las instrucciones bsicas son puts, print y printf:

puts. Despliega en la consola y aade un enter al final.
print. Despliega en la consola pero no aade el enter o salto de lnea al final.
printf. Permite formatear la salida de variables de forma similas a C y Java 5.

Ejemplo:

put s " put s f unci ona"
put s " con sal t os de l i nea. "

pr i nt "pr i nt f unci ona"
pr i nt " si n sal t os de l i nea. "

pr i nt f ( " \ n\ npr i nt f f or mat ea numer os como %7. 2f , y cadenas como
%s. " , 3. 14156, " est a")

La manera ms simple de leer una cadena en Ruby es ocupando la funcin gets:

pr i nt I nt r oduce t u nombr e:
nom= get s

- 119 -
Abstraccin de datos: Clases y objetos
Clases

Se mencionaba anteriormente que la base de la programacin orientada a
objetos es la abstraccin de los datos o los TDAs. La abstraccin de los datos se
da realmente a travs de las clases y objetos.

Def. Clase. Se puede decir que una clase es la implementacin real de un
TDA, proporcionando entonces la estructura de datos necesaria y sus operaciones.
Los datos son llamados atributos y las operaciones se conocen como mtodos.
[3]

La unin de los atributos y los mtodos dan forma al comportamiento
(comportamiento comn) de un grupo de objetos. La clase es entonces como la
definicin de un esquema dentro del cual encajan un conjunto de objetos.

El comportamiento debe ser descrito en trminos de responsabilidades [7].
Resolviendo el problema bajo esos trminos permite una mayor independencia
entre los objetos, al elevar el nivel de abstraccin.

En Programacin Estructurada el programa opera sobre estructuras de datos.
En contraste en Programacin Orientada a Objetos, el programa solicita a las
estructuras de datos que ejecuten un servicio.

Ejemplos de clases:

automvil,
persona,
libro,
revista,
reloj,
silla,
...
- 120 -
Obj etos e i nstanci as

Una de las caractersticas ms importantes de los lenguajes orientados a
objetos es la instanciacin. Esta es la capacidad que tienen los nuevos tipos de
datos, para nuestro caso en particular las clases de ser "instanciadas" en cualquier
momento.

El instanciar una clase produce un objeto o instancia de la clase requerida.
Todos los objetos son instancia de una clase [7].

Def. Objeto. Un objeto es una instancia de una clase. Puede ser identificado
en forma nica por su nombre y define un estado, el cul es representado por los
valores de sus atributos en un momento en particular [3].

El estado de un objeto cambia de acuerdo a los mtodos que le son
aplicados. Nos referimos a esta posible secuencia de cambios de estado como el
comportamiento del objeto:

Def. Comportamiento. El comportamiento de un objeto es definido por un
conjunto de mtodos que le pueden ser aplicados [3].

Instanciacin

Los objetos pueden ser creados de la misma forma que una estructura de
datos:

1. Estticamente. En tiempo de compilacin se le asigna un rea de memoria.

2. Dinmicamente. Se le asigna un rea de memoria en tiempo de ejecucin y su
existencia es temporal. Es necesario liberar espacio cuando el objeto ya no es
til; para esto puede ser que el lenguaje proporcione mecanismos de
recoleccin de basura.

- 121 -
En J ava, los objetos slo existen de manera dinmica, adems de que
incluye un recolector de basura para no dejar como responsabilidad del usuario la
eliminacin de los objetos de la memoria.

Clases en C++

Una clase entonces, permite encapsular la informacin a travs de atributos
y mtodos que utilizan la informacin, ocultando la informacin y la
implementacin del comportamiento de las clases.

La definicin de una clase define nuevos TDAs y la definicin en C++
consiste de la palabra reservada class, seguida del nombre de la clase y
finalmente el cuerpo de la clase encerrado entre llaves y finalizando con ;.

El cuerpo de la clase contiene la declaracin de los atributos de la clase
(variables) y la declaracin de los mtodos (funciones). Tanto los atributos como
los mtodos pertenecen exclusivamente a la clase y slo pueden ser usados a
travs de un objeto de esa clase.

Sintaxis:

class <nombr e_cl ase> {
<cuer po de l a cl ase>
};

Ejemplo:

class cEj empl o1 {
int x;
float y;
void f un( int a, float b) {
x=a;
y=b;
}
};
- 122 -

Miembros de una cl ase en C++

Una clase est formada por un conjunto de miembros que pueden ser datos,
funciones, clases anidadas, enumeraciones, tipos de dato, etc. Por el momento nos
vamos a centrar en los datos y las funciones (atributos y mtodos).

Es importante sealar que un miembro no puede ser declarado ms de una
vez.
16
Tampoco es posible aadir miembros despus de la declaracin de la clase.

Ejemplo:

class cEj empl o2{
int i ;
int i ; / / er r or
int j ;
int f unc( int, int) ;
};

Atributos miembro

Todos los atributos que forman parte de una clase deben ser declarados
dentro de la misma.

Mtodos miembro

Los mtodos al igual que los atributos, deber ser definidos en la clase, pero
el cuerpo de la funcin puede ir dentro o fuera de la clase. Si un mtodo se
declara completo dentro de la clase, se considera como inline.

La declaracin dentro de la clase no cambia con respecto a la declaracin de
una funcin, salvo que se hace dentro de la clase. Veamos un ejemplo parecido al

16
Aunque existe el concepto de sobrecarga que se ver ms adelante
- 123 -
inicial de esta seccin, pero ahora con el cuerpo de un mtodo fuera del cuerpo de
la clase.

Ejemplo:

/ / cdi go en ej empl o3. h
class cEj empl o3 {
public:
int x;
float y;
int f unX( int a) {
x=a;
return x;
}
float f unY( float) ;
};

Podemos ver que en la definicin de la clase se incluye un mtodo en lnea y
un prototipo de otro mtodo.

Para definir un mtodo miembro de una clase fuera de la misma, se debe
escribir antes del nombre del mtodo, el nombre de la clase con la que el mtodo
esta asociado. Para esto se ocupa el operador de resolucin de alcance ::.

Continuacin del ejemplo:

float cEj empl o3: : f unY( float b) {
y=b;
return y;
}

Reiteramos que al declarar los mtodos fuera de la clase no puede
mencionarse la declaracin de un mtodo que no est contemplado dentro de la
clase. Si esto fuera vlido, cualquier mtodo podra ganar acceso a la clase con
slo declarar una funcin adicional.

- 124 -
Ejemplo:

/ / er r or en decl ar aci n de un mt odo
class x{
public:
int a;
f ( ) ;
};

int x: : g( ) { / / er r or , el met odo debe ser f ( )
return a*=3. 1234;
}

La declaracin de una funcin miembro es considerada dentro del mbito de
su clase. Lo cual significa que puede usar nombres de miembros de la clase
directamente sin usar el operador de acceso de miembro de la clase.

Recordar que por convencin en la programacin orientada a objetos las
funciones son llamadas mtodos y la invocacin o llamada se conoce como
mensaje.

Un vistazo al acceso a miembros

Otra de las ventajas de la POO es la posibilidad de encapsular datos,
ocultndolos de otros objetos si es necesario. Para esto existen principalmente dos
calificadores que definen a los datos como pblicos o privados.

Miembros pblicos. Se utiliza cuando queremos dar a usuarios de una clase ) el
acceso a miembros de esa clase, los miembros deben ser declarados pblicos.

Sintaxis:

public:
<def i ni ci n de mi embr os>

- 125 -
Miembros privados. Si queremos ocultar ciertos miembros de una clase de los
usuarios de la misma, debemos declarar a los miembros como privados. De esta
forma nadie ms que los miembros de la clase pueden usar a los miembros
privados. Por omisin los miembros se consideran privados. En una estructura se
consideran pblicos por omisin.

Sintaxis:

private:
<def i ni ci n de mi embr os>

Normalmente, los atributos de la clase deben ser privados; as como los
mtodos que no sean necesarios externamente o que puedan conducir a un estado
inconsistente del objeto.
17

En el caso de los atributos, estos al ser privados deberan de contar con
mtodos de modificacin y de consulta pudiendo incluir alguna validacin.

Es una buena costumbre de programacin accesar a los atributos solamente
a travs de las funciones de modificacin, sobre todo si es necesario algn tipo de
verificacin sobre el valor del atributo.

Ejemplo:

/ / cdi go en ej empl o3. h
class cFecha {
private:
int di a;
int mes;
int an;

public:
char set Di a( int) ; / / poner d a
int get Di a( ) ; / / devuel ve d a
char set Mes( int) ;

17
Un estado inconsistente sera ocasionado por una modificacin indebida de los datos, por ejemplo una modificacin sin
validacin.
- 126 -
int get Mes( ) ;
char set An( int) ;
int get An( ) ;
};

Obj etos de cl ase en C++

Ya se ha visto como definir una clase, declarando sus atributos y sus
operaciones, mismas que pueden ir dentro de la definicin de la clase (inline) o
fuera. Ahora vamos a ver como es posible crear objetos o instancias de esa clase.

Hay que recordar que una de las caractersticas de los objetos es que cada
uno guarda un estado particular de acuerdo al valor de sus atributos
18
.

Lo ms importante de los lenguajes orientados a objetos es precisamente el
objeto, el cual es una identidad lgica que contiene datos y cdigo que manipula
esos datos.

En C++, un objeto es una variable de un tipo definido por el usuario [8].

Un ejemplo completo:


class cEj empl o3 {
public:
int i ;
int j ;
};

int mai n( ) {
cEj empl o3 e1;
cEj empl o3 e2;

18
A diferencia de la programacin modular, donde cada mdulo tiene un solo estado.
- 127 -
e1. i =10;
e1. j =20;

e2. i =100;
e2. j =20;

cout <<e1. i <<endl ;
cout <<e2. i <<endl ;

return 0;
}

Otro ejemplo, una cola:

class cCol a{
private:
int q[ 10] ;
int sl oc, r l oc;

public:
void i ni ( ) { / / f unci n en l nea
sl oc=r l oc=- 1;
}
char set ( int) ;
int get ( ) ;
};

#include " cCol a. h"


char cCol a: : set ( int val ) {
if( sl oc>=10) {
cout <<" l a col a est a l l ena" ;
return 0;
}
sl oc++;
q[ sl oc] =val ;
- 128 -
return 1;
}
int cCol a: : get ( ) {
if( r l oc==sl oc)
cout <<" l a col a est a vaci a" ;
else {
r l oc++;
return q[ r l oc] ;
}
}

/ / col a def i ni da en un ar r egl o
#include " cCol a. h"


int mai n( ) {
cCol a a, b, *pCol a= new cCol a; / / *pCol a=NULL y despu s
asi gnar l e

a. i ni ( ) ;
b. i ni ( ) ;
pCol a- >i ni ( ) ;
a. set ( 1) ;
b. set ( 2) ;
pCol a- >set ( 3) ;
a. set ( 11) ;
b. set ( 22) ;
pCol a- >set ( 33) ;
cout <<a. get ( ) <<endl ;
cout <<b. get ( ) <<endl ;
cout <<pCol a- >get ( ) <<endl ;

delete pCol a;
return 0;
}

- 129 -

Nota: tomar en cuenta las instrucciones siguientes para el precompilador en
el manejo de mltiples archivos.
#ifndef CCOLA_H
#define CCOLA_H
<definicin de la clase>
#endif

Clases en Java

La definicin en J ava, de manera similar a C++, consiste de la palabra
reservada class, seguida del nombre de la clase y finalmente el cuerpo de la clase
encerrado entre llaves.

Sintaxis:

class <nombr e_cl ase> {
}

Ejemplo
19
:

public class cEj empl o1 {
int x;
float y;
void f un( int a, float b) {
x=a;
y=b;
}
}

19
Algunos ejemplos como este no son programas completos, sino simples ejemplos de clases. Podrn ser
compilados pero no ejecutados directamente. Para que un programa corra debe contener o ser una clase
derivada de applet, o tener un mtodo main.
- 130 -
Miembros de una cl ase en Java

Los miembros en J ava son esencialmente los atributos y los mtodos de la
clase.

Ejemplo:

class cEj empl o2{
int i ;
int i ; / / er r or
int j ;
int f unc( int, int) {}
}

Atributos miembro

dentro de la misma.

La sintaxis mnima es la siguiente:

tipo nombr eAt r i but o;

Los atributos pueden ser inicializados desde su lugar de declaracin:

tipo nombr eAt r i but o = valor;

, en el caso de variables de objetos:

tipo nombr eAt r i but o = new Clase();

- 131 -
Mtodos miembro

Un mtodo es una operacin que pertenece a una clase. No es posible
declarar mtodos fuera de la clase. Adems, en J ava no existe el concepto de
mtodo prototipo como en C++.

Sin embargo, igual que en C++, la declaracin de una funcin mtodo
miembro es considerada dentro del mbito de su clase.

La sintaxis bsica para declarar a un mtodo:

tipoRetorno nombr eMt odo ( [ <par met r os>] ) {

}

Un aspecto importante a considerar es que el paso de parmetros en J ava es
realizado exclusivamente por valor. Datos bsicos y objetos son pasados por
valor. Pero los objetos no son pasados realmente, se pasan las referencias a los
objetos (i.e., una copia de la referencia al objeto).

Un vistazo al acceso a miembros

Si bien en J ava existen tambin los miembros pblicos y privados, estos
tienen una sintaxis diferente a C++. En J ava se define el acceso a cada miembro
de manera unitaria, al contrario de la definicin de acceso por grupos de
miembros de C++.

Miembros pblicos.

Sintaxis:

public <def i ni ci n de mi embr o>

Miembros privados.

- 132 -
Sintaxis:

private <def i ni ci n de mi embr os>

Recordatorio: Es una buena costumbre de programacin acceder a los atributos
solamente a travs de las funciones de modificacin, sobre todo si es necesario
algn tipo de verificacin sobre el valor del atributo. Estos mtodos de acceso y
modificacin comnmente tienen el prefijo get y set, respectivamente.

Ejemplo:

class Fecha {
private int di a;
private int mes, an;

public boolean set Di a( int d) {} / / poner d a
public int get Di a( ) {} / / devuel ve d a
public boolean set Mes( int m) {}
public int get Mes( ) {}
public boolean set An( int a) {}
public int get An( ) {}
}

Obj etos de cl ase en Java

En J ava todos los objetos son creados dinmicamente, por lo que se necesita
reservar la memoria de estos en el momento en que se van a ocupar. El operador
de J ava est basado tambin en el de C++y es new.
20

Asignacin de memoria al objeto

20
La instruccin new, ya haba sido usada para reservar memoria a un arreglo, ya que estos son considerados
objetos.
- 133 -
El operador new crea automticamente un rea de memoria del tamao
adecuado, y regresa la referencia del rea de memoria. Esta referencia debe de
recibirla un identificador de la misma clase de la que se haya reservado la
memoria.

Sintaxis:

i dent i f i cador = new Cl ase( ) ;

en el momento de declarar a la variable de objeto:

Cl ase i dent i f i cador = new Cl ase( ) ;

El concepto de new va asociado de la nocin de constructor, pero esta se
ver ms adelante, por el momento basta con adoptar esta sintaxis para poder
completar ejemplos de instanciacin.


public class Ej empl o3 {
public int i , j ;

public static void mai n( St r i ng ar gv[ ] ) {
Ej empl o3 e3= new Ej empl o3( ) ;
Ej empl o3 e1= new Ej empl o3( ) ;

e1. i =10;
e1. j =20;
e3. i =100;
e3. j =20;
Syst em. out. pr i nt l n( e1. i ) ;
Syst em. out. pr i nt l n( e3. i ) ;
}
}

Otro ejemplo, una estructura de cola:

class Col a{
- 134 -
private int q[ ] ;
private int sl oc, r l oc;

public void i ni ( ) {
sl oc=r l oc=- 1;
q=new int[ 10] ;
}

public boolean set ( int val ) {
if( sl oc>=10) {
Syst em. out. pr i nt l n( " l a col a est a l l ena" ) ;
return false;
}
sl oc++;
q[ sl oc] =val ;
return true;
}

public int get ( ) {
if( r l oc==sl oc) {
Syst em. out. pr i nt l n( " l a col a est a vaci a" ) ;
return - 1;
}
else {
r l oc++;
return q[ r l oc] ;
}
}
}

public class Pr uebaCol a {

Col a a= new Col a( ) ; / / new cr ea r eal ment e el obj et o
Col a b= new Col a( ) ; / / r eser vando l a memor i a
Col a pCol a= new Col a( ) ;

/ / I ni ci al i zaci on de l os obj et os
a. i ni ( ) ;
- 135 -
b. i ni ( ) ;
pCol a. i ni ( ) ;

a. set ( 1) ;
b. set ( 2) ;
pCol a. set ( 3) ;
a. set ( 11) ;
b. set ( 22) ;
pCol a. set ( 33) ;

Syst em. out. pr i nt l n( a. get ( ) ) ;
Syst em. out. pr i nt l n( a. get ( ) ) ;
Syst em. out. pr i nt l n( b. get ( ) ) ;
Syst em. out. pr i nt l n( b. get ( ) ) ;
Syst em. out. pr i nt l n( pCol a. get ( ) ) ;
Syst em. out. pr i nt l n( pCol a. get ( ) ) ;
}
}

- 136 -

Clases en Ruby

La definicin en Ruby, de manera similar a J ava y C++, consiste de la
palabra reservada class, seguida del nombre de la clase y finalmente el cuerpo de
la clase [9].

Sintaxis:

class <nombr e_cl ase>
end

Si la clase es contenida en un archivo la convencin es que el nombre del archivo
coincida con el nombre de la clase pero iniciando en minsculas. Una clase
Prueba estar idealmente en un archivo prueba.rb (en Windows se usa .rbw)

Ejemplo
21
:

class Ej empl o01
def f un a, b
x=a
y=b
end
end
Miembros de una cl ase en Ruby

Los miembros en Ruby son esencialmente los atributos y los mtodos de la
clase.

21
Algunos ejemplos como este no son programas completos, sino simples ejemplos de clases. Ruby es un
lenguaje interpretado. No existe un mtodo principal que inicie la ejecucin. El interprete recibe una lista de
instrucciones y ste comienza ejecutando de la lnea inicial hasta la ltima lnea.
- 137 -
Mtodos miembro

Un mtodo es una operacin que pertenece a una clase. Los mtodos son
muy importantes en Ruby. En Ruby no existen funciones, pues todo el cdigo es
representad en mtodos (asociados a objetos). Aunque Ruby permite definir
cdigo como funciones en otros lenguajes, en realidad ese cdigo es un mtodo
asociado (por omisin) a un objeto.

La sintaxis bsica para declarar a un mtodo:

def nombr eMt odo [ ( <par met r os> ) ]

end

Un aspecto importante a considerar es que la lista de parmetros, al igual que el
uso de variables, no requiere definir el tipo de dato, pues este se determina en el
momento de la llamada al mtodo.

Es posible aadir los smbolos ! o ? al final del nombre de un mtodo. ! indica
que el mtodo requiere ms atencin que la variante con el mismo nombre sin el
!. El smbolo ? indicara que el mtodo retorna un resultado boleano.

En Ruby es posible que un mtodo definido para una clase quede indefinido:

undef nombr eMt odo [ ( <par met r os> ) ]

Por ejemplo:

class Foo
def f oo
end
end

. . .

undef f oo
- 138 -

Un vistazo al acceso a mtodos

Si bien en Ruby existen tambin los miembros pblicos y privados, estos
son usados para proveer acceso a los mtodos, puesto que los atributos son
privados.

Mtodos pblicos. Accesibles donde la clase es visible.

Sintaxis:

public <l i st a de mt odos>

Mtodos privados. Accesibles solo por instancias de la clase.

Sintaxis:

private <l i st a de mt odos>

La lista de mtodos pblicos o privados debe hacer referencia a mtodos
previamente definidos. Esto puede ser la lista de mtodos despus de ser
definidos, o definirse el mtodo en ese momento. En Ruby, los mtodos son
pblicos por omisin [10].

Ejemplo:

class A
private
def met odo_pr i vado
# codigo
end
end

- 139 -
Atributos miembro

dentro de la misma. En Ruby los atributos son llamasoa variables de instancia, y
no requieren ser declarados fuera de los mtodos. Podemos usar variables de
instancia conforme se necesiten. Una variable de instancia debe llevar como
prefijo el smbolo @, por ejemplo:

@var i abl eI nst anci a

Ejemplo:

class I nst Test
def set _f oo( n)
@f oo = n
end
def set _bar ( n)
@bar = n
end
end

El detalle es que en Ruby las variables de instancia no son accesibles
externamente. Para poder accederlas debemos crear mtodos de acceso como en
el ejemplo pasado, o definir explcitamente el acceso a los atributos, lo que genera
mtodos con el nombre del atributo ( pero sin el @ ). Existen 3 tipos de acceso a
los atributos:

attr_accesor. Genera acceso de lectura y escritura a la variable de instancia.
attr_reader. Genera acceso de lectura sobre la variable de instancia.
attr_writer. Proporciona acceso de escritura sobre la variable de instancia.

Ejemplo:

class Usuar i o

attr_accessor :nombre
attr_accessor :apellidos
- 140 -
attr_reader :login
attr_writer :password
. . .
def muest r a
@nombr e+ +@apel l i dos
end
end

Obj etos de cl ase en Ruby

En Ruby todos los nmeros, arreglos, cadenas y dems entidades son
objetos, lo que permite aplicar mtodos definidos para esos objetos directamente
a las literales:

10. succ # 11
" hol a" . upcase # "HOLA"
[ 2, 1, 5, 3, 4] . sor t # [1,2,3,4,5]
obj et o. met odo

Esto implicara que cada objeto en Ruby es un objeto de alguna clase. De
hecho es posible preguntarle a un objeto a que clase pertenece:

" hol a" . class
Asignacin de memoria al objeto

En Ruby, un objeto es instanciado mediante la ejecucin del mtodo new, el
crea automticamente un rea de memoria del tamao adecuado, y regresa la
referencia del rea de memoria. El objeto instanciado tpicamente es asignado a
una variable.

Sintaxis:

i dent i f i cador = Cl ase. new

- 141 -

class Ej empl o3
@i # no es necesario
@j # especificar los atributos
def unMet odo x, y
@i =x
@j =y
put s " El val or de i es " + @i . t o_s
put s " El val or de j es " + @j . t o_s
end
end

require " Ej empl o3"
# load "Ejemplo3.rb"

obj 1 = Ej empl o3. new
obj 2 = Ej empl o3. new

obj 1. unMet odo 10, 20
obj 2. unMet odo 100, 20

Otro ejemplo, una estructura de cola:

class Col a
@q=[ ]
@sl oc= @r l oc=- 1

def i ni
@sl oc= @r l oc=- 1
@q=[ ]
end

def set val
if @sl oc>1000
put s " La col a est a l l ena"
return false
end
@sl oc+=1
@q[ @sl oc] =val
- 142 -
return true
end

def get
if @r l oc == @sl oc then
put s " La col a est a vaci a"
return false
else
@r l oc+=1
return @q[ @r l oc]
end
end
end

require " Col a"

a = Col a. new
b = Col a. new

a. i ni
b. i ni

a. set 1
b. set 2
a. set 11
b. set ( 22)

put s a. get
put s a. get
put s b. get
put s b. get ( )

a. get

- 143 -

- 144 -
Alcance de Cl ase en C++

El nombre de un miembro de una clase es local a la clase. Las funciones no
miembros se definen en un alcance de archivo.

Dentro de la clase los miembros pueden ser accesados directamente por
todos los mtodos miembros. Fuera del alcance la clase, los miembros de la clase
se pueden utilizar seguidos del operador de seleccin de miembro de punto .
del operador de seleccin de miembro de flecha , posteriormente al nombre
de un objeto de clase.

Ejemplo:

class cMi Cl ase{
public:
int ot r aFunci on( ) ;
};

int mai n ( ) {
cMi Cl ase cM;

cM. ot r aFunci on( ) ;
return 0;
}

Alcance de Cl ase en Java

El nombre de un miembro de una clase es local a la clase.

Dentro de la clase, los miembros pueden ser accesados directamente por
todos los mtodos miembros. Fuera del alcance la clase, los miembros de la clase
se pueden utilizar seguidos del operador de seleccin de miembro de punto . ,
posteriormente al nombre de un objeto de clase.

- 145 -
Ejemplo:

class Mi Cl ase{
public void ot r aFunci on( ) {
Syst em. out. pr i nt l n( " Met odo de l a cl ase Mi Cl ase" ) ;
}
}

public class Al cance {
public static void mai n ( St r i ng ar gv[ ] ) {
Mi Cl ase cM= new Mi Cl ase( ) ;
cM. ot r aFunci on( ) ;
}
}

Alcance de Cl ase en Ruby

Los atributos son privados y accesibles nicamente mediante mtodos
definidos por el programador o mediante los modificadores de accesoa los
atributos. El nombre del mtodo de una clase es local a la clase.

Dentro de la clase, los miembros pueden ser accesados directamente por
todos los mtodos miembros. Fuera del alcance la clase, nicamente los mtodos
de la clase se pueden utilizar, seguidos del operador de seleccin de miembro de
punto . , posteriormente al nombre de un objeto de clase.

Ejemplo:

class Mi Cl ase
public
def ot r aFunci on
put s " Met odo de l a cl ase Mi Cl ase"
end
end

def mi Mai n
- 146 -
cM= Mi Cl ase. new
cM. ot r aFunci on
end

mi Mai n

Usando l a pal abra reservada this en C++ y Java

Cuando en algun punto dentro del cdigo de algunos de los mtodos se
quiere hacer referencia al objeto ligado en ese momento con la ejecucin del
mtodo, podemos hacerlo usando la palabra reservada this.

Una razn para usarlo es querer tener acceso a algn atributo posiblemente
oculto por un parmetro del mismo nombre.

Tambin puede ser usado para regresar el objeto a travs del mtodo, sin
necesidad de realizar una copia en un objeto temporal.

La sintaxis es la misma en C++y en J ava, con la nica diferencia del
manejo del operador de indireccin * si, por ejemplo, se quiere regresar una
copia y no la referencia del objeto.

Ejemplo en C++:

Fecha Fecha: : get Fecha( ) {
return *this;
}

Ejemplo en J ava:

class Fecha {
private int di a;
private int mes, an;

public Fecha get Fecha( ) {
return this;
- 147 -
}

}

Usando l a pal abra reservada self en Ruby

En Ruby, para hacer referencia en un mtodo al objeto donde es ejecutado el
mtodo (el mismo que recibe el mensaje) se usa la palabra reservada self, en lugar
de this.

Ejemplo:

class Sel f Ej empl o
@x=0
@y=0
def get Sel f Ej empl o
return self
end
attr_accessor :x, :y
end

#cdigo de prueba
obj 1= Sel f Ej empl o. new

obj 1. x=10
put s obj 1. x
obj 1. y=" YY"
put s obj 1. y

obj 2=obj 1. get Sel f Ej empl o

put s obj 2. x

obj 1. y=123
put s obj 1. y # despliega 123
put s obj 2. y # despliega 123

- 148 -
Sobrecarga de operaciones

Es posible tener el mismo nombre para una operacin con la condicin de
que tenga parmetros diferentes. La diferencia debe de ser al menos en el tipo de
datos.

Si se tienen dos o ms operaciones con el mismo nombre y diferentes
parmetros se dice que dichas operaciones estn sobrecargadas.

El compilador sabe que operacin ejecutar a travs de la firma de la
operacin, que es una combinacin del nombre de la operacin y el nmero y tipo
de los parmetros.

El tipo de regreso de la operacin puede ser igual o diferente.

La sobrecarga
22
de operaciones sirve para hacer un cdigo ms legible y
modular. La idea es utilizar el mismo nombre para operaciones relacionadas. Si
no tienen nada que ver entonces es mejor utilizar un nombre distinto. A
contianuacin ejemplos de sobrecarga en C++y J ava.

Ejemplo en C++:

class Mi Cl ase{
int x;

public:
void modi f i ca( ) {
x++;
}
void modi f i ca( int y) {
x=y*y;
}
}

22
Tambin conocida como homonimia.
- 149 -
Ejemplo 2 en C++:

/ / f uer a de POO

int cuadrado( int i ) {
return i *i ;
}
double cuadrado( double d) {
return d*d;
}

int mai n( ) {
cout <<" 10 el evado al cuadr ado: " <<cuadrado( 10) <<endl ;
cout <<" 10. 5 el evado al cuadr ado: " <<cuadrado( 10. 5) <<endl ;
return 0;
}

Ejemplo en J ava:

class Mi Cl ase{
int x;
public void modifica( ) {
x++;
}
public void modifica( int y) {
x=y*y;
}
}

Ruby no soporta sobrecarga de operaciones. En Ruby la firma de un mtodo
es su nombre. Si dos mtodos son definidos con el mismo nombre, la ltima
implementacin definida es la que es esperada.

Ejemplo en Ruby:

class Mi Cl ase
attr_reader :x
- 150 -

def modi f i ca
@x+=1
end
def modi f i ca y
@x=y*y
end

end

#prueba
mc=Mi Cl ase. new

put s mc. x
# mc.modifica -- Error pues se ha redefinido el mtodo

mc. modi f i ca 10
put s mc. x

Constructores y destructores en C++

Con el manejo de los tipos de datos primitivos, el compilador se encarga de
reservar la memoria y de liberarla cuando estos datos salen de su mbito.

En la programacin orientada a objetos, se trata de proporcionar
mecanismos similares, aunque con mayor funcionalidad. Cuando un objeto es
creado es llamado un mtodo conocido como constructor, y al salir se llama a otro
conocido como destructor. Si no se proporcionan estos mtodos se asume la
accin ms simple.

Constructor

Un constructor es un mtodo con el mismo nombre de la clase. Este mtodo
no puede tener un tipo de dato y si puede permitir la homonimia o sobrecarga.

- 151 -
Ejemplo:

class Col a{
private:
int q[ 100] ;
int sl oc, r l oc;

public:
Col a( ) ; / / const r uct or
void put ( int) ;
int get ( ) ;
};

/ / i mpl ement aci n del const r uct or
Col a: : Col a ( ) {
sl oc=r l oc=0;
cout <<" Col a i ni ci al i zada \ n" ;
}

Un constructor si puede ser llamado desde un mtodo de la clase.

Constructor de Copia

Es til agregar a todas las clases un constructor de copia que reciba como
parmetro un objeto de la clase y copie sus datos al nuevo objeto.

C++proporciona un constructor de copia por omisin, sin embargo es una
copia a nivel de miembro y puede no realizar una copia exacta de lo que
queremos. Por ejemplo en casos de apuntadores a memoria dinmica, se tendra
una copia de la direccin y no de la informacin referenciada.

Sintaxis:

<nombr e cl ase>( const <nombr e cl ase> &<obj et o>) ;

Ejemplo:

- 152 -
/ / ej empl o de const r uct or de copi a
#include <t i me. h>
#include <st dl i b. h>


class Ar r {
private:
int a[ 10] ;
public:

Ar r ( int x=0) {
for( int i =0; i <10; i ++) {
if ( x==0)
x=r and( ) ;
a[ i ] =x;
}
}

Ar r ( const Arr &copia) { / / const r uct or de copi a
for( int i =0; i <10; i ++)
a[ i ] =copi a. a[ i ] ;
}

char set ( int, int) ;
int get ( int) const ;
int get ( int) ;
};

char Ar r : : set ( int pos, int val ) {
if( pos>=0 && pos<10) {
a[ pos] =val ;
return 1;
}
return 0;
}
int Ar r : : get ( int pos) const {
if( pos>=0 && pos<10)
return a[ pos] ;
- 153 -
/ / a[ 9] =0; er r or en un met odo const ant e
return 0;
}

int Ar r : : get ( int pos) { / / no es necesar i o sobr ecar gar
if( pos>=0 && pos<10) / / si el met odo no modi f i ca
return a[ pos] ;
return 0;
}

int mai n( ) {
Ar r a( 5) , b;
sr and( t i me( NULL) ) ;

a. set ( 0, 1) ;
a. set ( 1, 11) ;
cout <<a. get ( 0) <<endl ;

b. set ( 0, 2) ;
b. set ( 1, 22) ;
cout <<b. get ( 0) <<endl ;

Ar r d( a) ;
cout <<d. get ( 0) <<endl ;
cout <<d. get ( 1) <<endl ;

return 0;
}

Destructor

La contraparte del constructor es el destructor. Este se ejecuta momentos
antes de que el objeto sea destruido, ya sea porque salen de su mbito o por medio
de una instruccin delete. El uso ms comn para un destructor es liberar la
memoria asignada dinmicamente, aunque puede ser utilizado para otras
operaciones de finalizacin, como cerrar archivos, una conexin a red, etc.
- 154 -

El destructor tiene al igual que el constructor el nombre de la clase pero con
una tilde como prefijo (~).

El destructor tampoco regresa valores ni tiene parmetros.

Ejemplo:

class Col a{
private:
int q[ 100] ;
int sl oc, r l oc;

public:
Col a( ) ; / / const r uct or
~Col a( ) ; / / dest r uct or
void put ( int) ;
int get ( ) ;
};

Col a: : ~Col a( ) {
cout <<" col a dest r ui da\ n" ;
}

Ejemplo completo de Cola con constructor y destructor:

/ / col a def i ni da en un ar r egl o
/ / i ncl uye const r uct or es y dest r uct or es de ej empl o
#include <st r i ng. h>
#include <st di o. h>


class Col a{
private:
int q[ 10] , sl oc, r l oc;
char *nom;

- 155 -
public:
Col a( char *cad=NULL) { / / f unci on en l i nea
if( cad) { / / cadena! =NULL
nom=new char[ st r l en( cad) +1] ;
st r cpy( nom, cad) ;
}else
nom=NULL;
sl oc=r l oc=- 1;
}
~Col a( ) {
if( nom) { / / nom! =NULL
cout <<" Col a : " <<nom<<" dest r ui da\ n" ;
delete [ ] nom;
}
}

char set ( int) ;
int get ( ) ;
};

char Col a: : set ( int val ) {
if( sl oc>=10) {
cout <<" l a col a est a l l ena" ;
return 0;
}
sl oc++;
q[ sl oc] =val ;
return 1;
}
int Col a: : get ( ) {
if( r l oc==sl oc)
cout <<" l a col a est a vaci a" ;
else {
r l oc++;
return q[ r l oc] ;
}
return 0;
}

int mai n( ) {
- 156 -
Col a a( " Col a a" ) , b( " Col a b" ) ,
*pCol a= new Col a( " Col a di nami ca pCol a" ) ;
a. set ( 1) ;
b. set ( 2) ;
pCol a- >set ( 3) ;
a. set ( 11) ;
b. set ( 22) ;
pCol a- >set ( 33) ;

delete pCol a;
}

Constructores y fi nal izadores en Java

En J ava, cuando un objeto es creado es llamada un mtodo conocido como
constructor, y al salir se llama a otro conocido como finalizador
23
. Si no se
proporcionan estos mtodos se asume la accin ms simple.

Constructor

Un constructor es un mtodo con el mismo nombre de la clase. Este mtodo
no puede tener un tipo de dato de retorno y si puede permitir la homonimia o
sobrecarga, y la modificacin de acceso al mismo.

Ejemplo:

public class Col a{
private int q[ ] ;

23
En C++no existe el concepto de finalizador, sino el de destructor, porque su tarea primordial es liberar la
memoria ocupada por el objeto, cosa que no es necesario realizar en Java.
- 157 -
private int sl oc, r l oc;
public void put ( int) { . . . }
public int get ( ) { . . . }
/ / i mpl ement aci n del const r uct or
public Cola ( ) {
sl oc=r l oc=0;
q= new int[ 100] ;
Syst em. out. pr i nt l n( " Col a i ni ci al i zada " ) ;
}
}

El constructor se ejecuta en el momento de asignarle la memoria a un
objeto, y es la razn de usar los parntesis junto al nombre de la clase al usar la
instruccin new:

Fecha f = new Fecha( 10, 4, 2007) ;

Si no se especifica un constructor, J ava incluye uno predeterminado, que
asigna memoria para el objeto e inicializa las variables de instancia a valores
predeterminados. Este constructor se omite si el usuario especifica uno o ms por
parte del programador.

Finalizador

La contraparte del constructor en J ava es el mtodo finalize o finalizador.
Este se ejecuta momentos antes de que el objeto sea destruido por el recolector de
basura. El uso ms comn para un finalizador es liberar los recursos utilizados
por el objeto, como una conexin de red o cerrar algn archivo abierto.

No es muy comn utilizar un mtodo finalizador, ms que para asegurar
situaciones como las mencionadas antes. El mtodo ira en trminos generales
como se muestra a continuacin
24
:

24
No se ha mencionado el modificador protected. Este concepto se explicar una vez que se haya visto el
manejo de herencia.
- 158 -
protected void f i nal i ze( ) {

}

El finalizador puede ser llamado como un mtodo normal, inclusive puede ser
sobrecargado, pero un finalizador con parmetros no puede ser ejecutado
automticamente por la mquina virtual de J ava. Se recomiendo evitar el definir
un finalizador con parmetros.

Inicial izadores en Ruby

En Ruby, el mtodo que podemos usar para inicializar un objeto es llamado
initialize. No es llamado consturctor porque, en Ruby, son internamente dos
procesos separados. El mtodo initialize no es un constructor y es definido
automticamente como privado.

La explicacin para esto es que las clases en Ruby son instancias de la clase
Class. Por cada clase definida, un objeto de tipo Class es creado y asignado a una
constante del nombre especificado en la declaracin de la clase. Cuando el
mtodo new es llamado (NombreClase.new) para crear un objeto, se ejecuta por
default el mtodo new de Class, el cual ejecuta al mtodo allocate para asignar la
memoria del objeto, y por ltimo, el mtodo initialize del nuevo objeto es
ejecutado.

Sintaxis

class Nombr eCl ase
def i ni t i al i ze [ ( l i st a de par met r os) ]
<cdi go>
end
...
end

- 159 -
obj = Nombr eCl ase. new [ ( par met r os) ]

Ejemplo:

class Col a

def i ni t i al i ze
@sl oc= @r l oc=- 1
@q=[ ]
end
. . .
end

- 160 -
Miembros estticos en C++

Cada objeto tiene su propio estado, pero a veces es necesario tener valores
por clase y no por objeto. En esos casos se requiere tener atributos estticos que
sean compartidos por todos los objetos de la clase.

Existe solo una copia de un miembro esttico y no forma parte de los
objetos de la clase. Este tipo de miembro son tambin conocidos como miembros
de clase.

Objeto n
Objeto 2
Objeto 1
Clase
(Estado de la clase)
(Estado del objeto)
(Estado del objeto)
(Estado del objeto)

Ejemplo:

class Obj et o{
private:
char nombr e[ 10] ;
static int numObj et os;
public:
Obj et o( char *cadena=NULL) ;
~Obj et o( ) ;
};

Obj et o: : Obj et o( char *cadena) {
if( cadena! =NULL)
st r cpy( nombr e, cadena) ;
else
nombr e=NULL;
- 161 -
numObj et os++;
}

Obj et o: : ~Obj et o( ) {
numObj et os- - ;
}

Un miembro esttico es accesible desde cualquier objeto de la clase o
mediante el operador de resolucin de alcance binario (::) y el nombre de la clase,
dado que el miembro esttico existe aunque no haya instancias de la clase.

Sin embargo, el acceso sigue restringido bajo las reglas de acceso a
miembros:

Si se quiere accesar a un miembro esttico que es privado deber hacerse
mediante un mtodo pblico.
Si no existe ninguna instancia de la clase entonces deber ser por medio
de un mtodo pblico y esttico.

Adems, un mtodo esttico solo puede tener acceso a miembros estticos.

Los atributos estticos deben de ser inicializados al igual que los atributos
constantes, fuera de la declaracin de la clase. Por ejemplo:

int Cl ase: : at r i but o=0; int const Cl ase: : ATRCONST=50;

Ejemplo :

/ / pr ueba de mi embr os est t i cos


class Per sona{
private:
- 162 -
static int nPer sonas;
static const int MAX;
char *nombr e;

public:
Per sona( char *c=NULL) {
if( c! =NULL) {
nombr e= new char[ st r l en( c) +1] ;
st r cpy( nombr e, c) ;
cout <<" Per sona: " <<nombr e<<endl ;
}else{
nombr e=NULL;
cout <<" Per sona: " <<endl ;
}
nPer sonas++;
}

~Per sona( ) {
cout <<" el i mi nando per sona : " <<nombr e<<endl ;
if( nombr e)
delete [ ] nombr e;
nPer sonas- - ;
}

static int get Max( ) {
return MAX;
}

static int get nPer sonas( ) {
return nPer sonas;
}
};

int Persona::nPersonas=0;
const int Persona::MAX=10;

int mai n( ) {

cout <<" Mxi mo de per sonas: " <<Per sona: : getMax( ) <<endl ;
- 163 -
cout <<" Nmer o de per sonas:
" <<Per sona: : getnPersonas( ) <<endl ;

Per sona per 1;
cout <<" Mxi mo de per sonas: " <<Per sona: : getMax( ) <<endl ;
cout <<" Nmer o de per sonas: "
<<Per sona: : getnPersonas( ) <<endl ;

Per sona per 2( " per sona 2" ) ;
cout <<" Mxi mo de per sonas: " <<per 2. getMax( ) <<endl ;
cout <<" Nmer o de per sonas: " <<per 2. getnPersonas( ) <<endl ;
return 0;
}

Miembros estticos en Java

Un miembro esttico en J ava se maneja de la misma forma que en C++.
Cada uno de los objetos tiene su propio estado independiente del resto de los
objetos, compartiendo al mismo tiempo un estado comn al tener todos los
objetos acceso al estado de la clase, el cual es nico y existe de forma
independiente.

Ejemplo:

public class Obj et o{
private St r i ng nombr e;
private static int numObjetos;
public Obj et o( St r i ng cadena) {
if( cadena. l engt h( ) ! =0)
nombr e=cadena;
else
nombr e=" cadena por omi si on" ;
numObjetos++;
}

public static int get NumObj et os( ) {
return numObjetos;
}
- 164 -

Syst em. out. pr i nt l n( " Obj et os: " +
getNumObjetos( ) ) ;
Obj et o. getNumObjetos( ) ) ;

Obj et o uno, dos;
uno= new Obj et o( " " ) ;
dos= new Obj et o( " Obj et o dos" ) ;
uno. getNumObjetos( ) ) ;
dos. getNumObjetos( ) ) ;
}
}

Otro ejemplo :

/ / pr ueba de mi embr os est t i cos
public class Per sona{
private static int nPersonas=0;
private static final int MAX=10;
St r i ng nombr e;

public Per sona( St r i ng c) {
if( c. l engt h( ) ! =0)
nombr e= new St r i ng( c) ;
else
nombr e=" " ;
Syst em. out. pr i nt l n( " Per sona: " +nombr e) ;
nPersonas++;
}

public static int get Max( ) {
return MAX;
}
public static int get nPer sonas( ) {
return nPersonas;
}
- 165 -

Syst em. out. pr i nt l n( " Maxi mo de per sonas:
" +Per sona. getMax( ) ) ;
Syst em. out. pr i nt l n( " Numer o de per sonas:
" +Per sona. getnPersonas( ) ) ;

Per sona per 1= new Per sona( " " ) ;

Per sona per 2= new Per sona( " per sona 2" ) ;
" +per 2. getMax( ) ) ;
" +per 2. getnPersonas( ) ) ;

Per sona per 3= new Per sona( " per sona 3" ) ;

}
}

- 166 -
Miembros de clase en Ruby

Los elementos estticos en Ruby son conocidos como miembros de clase, el
cual es un trmino tambin usado en otros lenguajes debido a que el mbito de los
miembros va ms all del objeto pues existen en la clase sin depender de un
objeto en particular y representan, como ya mencionamos, un estado de la clase.

Atributos de clase

Las variables de clase en Ruby son nombradas usando @@ como prefijo y
deben ser inicializadas antes de ser usadas en definiciones de mtodos.
Referenciar un atributo de clase no inicializado genera un error. Las variables de
clase son compartidas entre descendientes de las clases donde estas fueron
definidas.

Mtodos de clase

Los mtodos de clase son definidos en Ruby usando como prefijo el nombre
de la clase o la palabra reservada self seguido de punto y el nombre del mtodo de
clase. self se resuelve como el nombre de la clase en este caso, siendo un
comportamiento distinto a cuando es usado dentro de un mtodo (self se resuelve
como el objeto en ejecucin).

Ejemplo:

class Per sona
@@nPer sonas=0
@@MAX=100 # no es una constante
@nombr e
def i ni t i al i ze nom
@nombr e=nom
put s " Per sona: " + @nombr e if nom. si ze>0
@@nPer sonas+=1
end

- 167 -
def self. get Max
return @@MAX
end

def Per sona. get nPer sonas
return @@nPer sonas
end

end

#cdigo principal

put s " Numer o maxi mo de per sonas: #{Per sona. get Max}"
put s " Numer o de per sonas: #{Per sona. get nPer sonas}"

per 1 = Per sona. new " Per sona 1"
put s " Numer o maxi mo de per sonas: #{Per sona. get Max}"
put s " Numer o de per sonas: #{Per sona. get nPer sonas}"

per 2 = Per sona. new " Per sona 2"
put s Per sona. get Max
put s Per sona. get nPer sonas
# puts per2.getMax -- error

A diferencia de C++y J ava, en Ruby un mtodo de clase no puede ser
accedido mediante un objeto. Un mtodo de clase solo puede ser usado
externamente mediante el nombre de la clase.

- 168 -
Obj etos constantes en C++

Es posible tener objetos de tipo constante, los cuales no podrn ser
modificados en ningn momento.
25
Tratar de modificar un objeto constante se
detecta como un error en tiempo de compilacin.

Sintaxis:

const <cl ase> <l i st a de obj et os>; const cHor a h1( 9, 30, 20) ;

Para estos objetos, algunos compiladores llegan a ser tan rgidos en el
cumplimiento de la instruccin, que no permiten que se hagan llamadas a
mtodos sobre esos objetos. La compilacin estandar permite la ejecucin de
mtodos, siempre y cuando no modifiquen el estado del objeto.

Si se quiere consultar al objeto mediante llamadas a mtodos get, lo
correcto es declarar mtodos con la palabra reservada const, para permitirles
actuar libremente sobre los objetos sin modificarlo. La sintaxis requiere aadir
despus de la lista de parmetros la palabra reservada const en la declaracin y en
su definicin.

Sintaxis:

Declaracin.

<t i po> <nombr e> ( <par met r os>) const;

Definicin del mtodo fuera de la declaracin de la clase.

<t i po> <cl ase> : : <nombr e> ( <par met r os>) const {
<cdi go>
}

25
Ayuda a cumplir el principio del mnimo privilegio, donde se debe restringir al mximo el acceso a los
datos cuando este acceso estara de sobra. [1]
- 169 -

Definicin del mtodo dentro de la declaracin de la clase.

<t i po> <nombr e> ( <par met r os>) const {
<cdi go>
}

Los compiladores generalmente restringen el uso de mtodos constantes a
objetos constantes. Para solucionarlo es posible sobrecargar el mtodo con la
nica diferencia de la palabra const, aunque el resto de la firma del mtodo sea la
misma.

Un mtodo puede ser declarado dos veces tan slo con que la firma del
mtodo difiera por el uso de const. Objetos constantes ejecutarn al mtodo
definido con const, y objetos variables ejecutarn al mtodo sin esta restriccin.
De hecho, un objeto variable puede ejecutar el mtodo no definido con const por
lo que si el objetivo del mtodo es el mismo, y este no modifica al objeto (e.g.,
mtodos tipo get) bastara con definir al mtodo una vez.
26

Los constructores no necesitan la declaracin const, puesto que deben poder
modificar al objeto.

Ejemplo:

#include <t i me. h>
#include <st dl i b. h>


class Ar r {
private:
int a[ 10] ;
public:

26
Adems, declarar a los mtodos get y otros mtodos que no modifican al objeto con el calificador const es
una buena prctica de programacin.
- 170 -
Ar r ( int x=0) {
sr and( t i me( NULL) ) ;
for( int i =0; i <10; i ++) {
if ( x==0)
x=r and( ) %100;
a[ i ] =x;
}
}
char set ( int, int) ;
int get ( int) const ;
int get ( int) ;
};

char Ar r : : set ( int pos, int val ) {
if( pos>=0 && pos<10) {
a[ pos] =val ;
return 1;
}
return 0;
}

int Ar r : : get ( int pos) const {
if( pos>=0 && pos<10)
return a[ pos] ;
/ / a[ 9] =0; er r or en un mt odo const ant e
return 0;
}

int Ar r : : get ( int pos) { / / no es necesar i o sobr ecar gar
if( pos>=0 && pos<10) / / si el mt odo no modi f i ca
return a[ pos] ;
return 0;
}

int mai n( ) {
const Ar r a( 5) , b;
Ar r c;

/ / a. set ( 0, 1) ; / / er r or l l amar a un mt odo no const
- 171 -
/ / b. set ( 0, 2) ; / / par a un obj et o const ant e ( coment ar est as
l i neas)
c. set ( 0, 3) ;
/ / a. set ( 1, 11) ; / / er r or l l amar a un mt odo no const
/ / b. set ( 1, 22) ; / / par a un obj et o const ant e ( coment ar est as
l i neas)
c. set ( 1, 33) ;
cout <<a. get ( 0) <<endl ; / / ej ecut a i nt get ( i nt ) const ;
cout <<c. get ( 0) <<endl ; / / ej ecut a i nt get ( i nt ) ;
cout <<c. get ( 1) <<endl ;
return 0;
}

Obj etos fi nal es en Java

Ya se mencion en la seccin de fundamentos de J ava el uso de la palabra
reservada final, la cual permite a una variable ser inicializada slo una vez. En el
caso de los objetos o referencias a los objetos el comportamiento es el mismo. Si
se agrega la palabra final a la declaracin de una referencia a un objeto, significa
que la variable podr ser inicializada una sola vez, en el momento que sea
necesario.

Sintaxis:

final <cl ase> <l i st a de i dent i f i cador es de obj et os>;

final Hor a h1= new Hor a( 9, 30, 20) ;

Es importante remarcar que no es el mismo sentido de const en C++. Aqu
lo nico que se limita es la posibilidad de una variable de referencia a ser
inicializada de nuevo, pero no inhibe la modificacin de miembros.

- 172 -
Por ejemplo:

final Li ght aLi ght = new Li ght ( ) ; / / var i abl e l ocal f i nal
aLi ght . noOf What t s = 100; / / Ok. Cambi o en el edo. del obj et o

aLi ght = new Li ght ( ) ; / / I nvl i do. No se puede modi f i car l a
r ef er enci a

Ejemplo:

class Fecha {
private int di a;
private int mes, ao;

public Fecha( ) {
di a=mes=1;
ao=1900;
}
public boolean set Di a( int d) {
if ( d >=1 && d<=31) {
di a= d;
return true;
}
return false;

} / / poner d a
public int get Di a( ) {
return di a;
} / / devuel ve d a
public boolean set Mes( int m) {
if ( m>=1 && m<=12) {
mes=m;
return true;
}
return false;
}
public int get Mes( ) {
return mes;
}
public boolean set Ao( int a) {
- 173 -
if ( a>=1900) {
ao=a;
return true;
}
return false;
}
public int get Ao( ) {
return ao;
}
}

public class Mai nF {

final Fecha f ;

f = new Fecha( ) ;

f . set Di a( 10) ;
f . set Mes( 3) ;
f . set Ao( 2001) ;

Syst em. out. pr i nt l n( f . get Di a( ) +" / " +f . get Mes( ) +" / " +f . get Ao(
) ) ;
f = new Fecha( ) ; / / Er r or : l a var i abl e f es f i nal y no
puede ser r easi gnada
}
}

Obj etos constantes en Ruby

Los objetos constantes ya fueron indirectamente explicados al mencionar el
manejo de constantes en Ruby, debido a que todos los datos son manejados como
objetos. Recordemos que deben empezar con una letra mayscula y pueden ser
definidas dentro de una clase o mdulo y sern visibles dentro de ese mbito. Una
constante definida fuera de un clase o mdulo ser vista globalmente. Es posible
reasignar un valor a una constante, pero esto producir una advertencia (pero no
un error).
- 174 -

Ejemplo:

class Fecha
@di a= @mes =1
@ani o=1900
end

def set Di a di a
if di a>=1 && di a<=31
@di a=di a
return true
end
return false
end

def set Mes mes
if mes>=1 && mes<=12
@mes=mes
return true
end
return false
end

def set Ani o a
if a>=1900
@ani o=a
return true
end
return false
end

attr_reader :dia, :mes, :anio
end

#Cdigo de prueba

Fe = Fecha. new # es constante por ser nombrada con una
mayscula como prefijo
- 175 -

Fe. set Di a 10
Fe. set Mes 3
Fe. set Ani o 2008

put s Fe. di a. t o_s+" / " +Fe. mes. t o_s+" / " +Fe. ani o. t o_s
# :
put s " #{Fe. di a}/ #{Fe. mes}/ #{Fe. ani o}"

Fe=Fecha.new # genera un warning pero no es un error al ser
reasignado el identificador constante

- 176 -
Funciones amigas en C++

En C++existe la amistad. Aunque algunos la consideran como una
intrusin a la encapsulacin o a la privacidad de los datos:

"... la amistad corrompe el ocultamiento de informacin y debilita el valor del
enfoque de diseo orientado a objetos" [11]

Un amigo de una clase es una funcin u otra clase que no es miembro de la
clase, pero que tiene permiso de usar los miembros pblicos y privados de la
clase.
Es importante sealar que el mbito de una funcin amiga no es el de la
clase, y por lo tanto los amigos no son llamados con los operadores de acceso de
miembros.

Sintaxis para una funcin amiga:

class <nombr eCl ase> {
friend <tipo> <met odo>( ) ;
. . .
public:
. . .
};

Sintaxis para una clase amiga:

class <nombr eCl ase> {
friend <nombr eCl aseAmi ga>;
. . .
public:
. . .
};

- 177 -
Las funciones o clases amigas no son privadas ni pblicas (o protegidas),
pueden ser colocadas en cualquier parte de la definicin de la clase, pero se
acostumbra que sea al principio.

Como la amistad entre personas, esta es concedida y no tomada. Si la clase
B quiere ser amigo de la clase A, la clase A debe declarar que la clase B es su
amiga.

La amistad no es simtrica ni transitiva: si la clase A es un amigo de la
clase B, y la clase B es un amigo de la clase C, no implica:

Que la clase B sea un amigo de la clase A.

Que la clase C sea un amigo de la clase B.

Que la clase A sea un amigo de la clase C.

Ejemplo 1:

/ / Ej empl o de f unci on ami ga con acceso a mi embr os pr i vados


class Cl aseX{
friend void set X( Cl aseX &, int) ; / / decl ar aci n f r i end
public:
Cl aseX( ) {
x=0;
}
void pr i nt ( ) const {
cout <<x<<endl ;
}
private:
int x;
};
- 178 -

void setX( Cl aseX &c, int val ) {
c. x=val ; / / es l egal el acceso a mi ebr os pr i vados por
ami st ad.
}

int mai n( ) {
Cl aseX pr ;

cout <<" pr . x despus de i nst anci aci n : " ;
pr . pr i nt ( ) ;
cout <<" pr . x despus de l a l l amada a l a f unci n ami ga set X
: " ;
set X( pr , 10) ;
pr . pr i nt ( ) ;
}

Ejemplo 2:

/ / ej empl o 2 de f unci ones ami gas


class Li nea;

class Recuadr o {
friend int mi smoCol or ( Li nea, Recuadr o) ;

private:
int col or ; / / col or del r ecuadr o
int xsup, ysup; / / esqui na super i or i zqui er da
int xi nf , yi nf ; / / esqui na i nf er i or der echa

public:
void ponCol or ( int) ;
void def i ni r Recuadr o( int, int, int, int) ;
};

- 179 -
class Li nea{
friend int mi smoCol or ( Li nea, Recuadr o) ;

private:
int col or ;
int xI ni ci al , yI ni ci al ;
int l on;

public:
void ponCol or ( int) ;
void def i ni r Li nea( int, int, int) ;
};

int mi smoCol or ( Li nea l , Recuadr o r ) {
if( l . col or ==r . col or )
return 1;
return 0;
}

/ / mt odos de l a cl ase Recuadr o
void Recuadr o: : ponCol or ( int c) {
col or =c;
}

void Recuadr o: : def i ni r Recuadr o( int x1, int y1, int x2, int y2)
{
xsup=x1;
ysup=y1;
xi nf =x2;
yi nf =y2;
}

/ / mt odos de l a cl ase Li nea
void Li nea: : ponCol or ( int c) {
col or =c;
}

void Li nea: : def i ni r Li nea( int x, int y, int l ) {
xI ni ci al =x;
yI ni ci al =y;
- 180 -
l on=l ;
}

int mai n( ) {
Recuadr o r ;
Li nea l ;

r . def i ni r Recuadr o( 10, 10, 15, 15) ;
r . ponCol or ( 3) ;

l . def i ni r Li nea( 2, 2, 10) ;
l . ponCol or ( 4) ;

if( ! mi smoCol or ( l , r ) )
cout <<" No t i enen el mi smo col or " <<endl ;

/ / se ponen en el mi smo col or
l . ponCol or ( 3) ;

if( mi smoCol or ( l , r ) )
cout <<" Ti enen el mi smo col or " ;
return 0;
}

- 181 -
Sobrecarga de operadores en C++

C++no permite la creacin de nuevos operadores, pero si permite en
cambio sobrecargar los operadores existentes para que se utilicen con los objetos.
De esta forma se les da a los operadores un nuevo significado de acuerdo al
objeto sobre el cual se aplique.

Para sobrecargar un operador, se define un mtodo que es invocado cuando
el operador es aplicado sobre ciertos tipos de datos.

Para utilizar un operador con objetos, es necesario que el operador este
sobrecargado, aunque existen dos excepciones:

El operador de asignacin =, puede ser utilizado sin sobrecargarse
explcitamente, pues el comportamiento por omisin es una copia a nivel de
miembro de los miembros de la clase. Sin embargo no debe de usarse si la
clase cuenta con miembros a los que se les asigne memoria de manera
dinmica.

El operador de direccin &, esta sobrecargado por omisin para devolver la
direccin de un objeto de cualquier clase.

Algunas restri cci ones:

1. Operadores que no pueden ser sobrecargados:

. .* :: ?: sizeof

2. La precedencia de un operador no puede ser modificada. Deben usarse los
parntesis para obligar un nuevo orden de evaluacin.

3. La asociatividad de un operador no puede ser modificada.

- 182 -
4. No se puede modificar el nmero de operandos de un operador. Los operadores
siguen siendo unarios o binarios.

5. No es posible crear nuevos operadores.

6. No puede modificarse el comportamiento de un operador sobre tipos de datos
definidos por el lenguaje.

La sintaxis para definir un mtodo con un operador difiere de la definicin
normal de un mtodo, pues debe indicarse el operador seguido de la palabra
reservada operator :

<t i po> operator <oper ador > ( <ar gument os>) ;

<t i po> operator <oper ador > ( <ar gument os>) {
<cuer po del mt odo>
}

Para la definicin fuera de la clase:

<t i po> <cl ase>: : operator <oper ador > ( <ar gument os>) {
<cuer po del mt odo>
}

- 183 -

Ejemplo:

/ / pr ogr ama de ej empl o de sobr ecar ga de oper ador es.

class Punt o {
float x, y;
public:
Punt o( float xx=0, float yy=0) {
x=xx;
y=yy;
}
float magni t ud( ) ;
Punt o operator =( Punt o) ;
Punt o operator +( Punt o) ;
Punt o operator - ( ) ;
Punt o operator *( float) ;
Punt o operator *=( float) ;
Punt o operator ++( ) ; / / pr ef i j o
Punt o operator ++( int) ; / / posf i j o

int operator >( Punt o) ;
int operator <=( Punt o) ;
};

Punt o Punt o: : operator =( Punt o a) { / / copi a o asi gnaci n
x=a. x;
y=a. y;
return *this;
}

Punt o Punt o: : operator +( Punt o p) {
return Punt o( x+p. x, y+p. y) ;
}

- 184 -
Punt o Punt o: : operator - ( ) {
return Punt o( - x, - y) ;
}

Punt o Punt o: : operator *( float f ) {
Punt o t emp;
t emp=Punt o( x*f , y*f ) ;
return t emp;
}

/ / i ncr ement o pr ef i j o
Punt o Punt o: : operator ++( ) {
x++;
y++;
return *this;
}

/ / i ncr ement o posf i j o
Punt o Punt o: : operator++( int)
{
Punt o t emp= *this;
x++;
y++;
return t emp;
}

int Punt o: : operator >( Punt o p) {
return ( x>p. x && y>p. y) ? 1 : 0;
}

int Punt o: : operator <=( Punt o p) {
return ( x<=p. x && y<=p. y) ? 1 : 0;
}

int mai n( ) {
Punt o a( 1, 1) ;
Punt o b;
Punt o c;

b++;
- 185 -
++b;
c=b;
c=a+b;
c=- a;
c=a*. 5;

return 0;
}

- 186 -

Ejercicio : Crear una clase String para el manejo de cadenas. Tendr dos
atributos: apuntador a carcter y un entero tam, para almacenar el tamao de la
cadena. Sobrecargar operadores = (asignacin) e (==) igualdad. Usar un
programa de prueba.
La estructura ser la siguiente:

cl ass St r i ng{
char *s;
i nt t am;
publ i c:
St r i ng( char *=NULL) ;
St r i ng( const St r i ng &copi a) ; / / const r uct or de copi a
~St r i ng( ) ;
/ / sobr ecar ga de const r uct or de asi gnaci n
const St r i ng &operator =( const St r i ng &) ;
/ / i gual dad
i nt operator ==( const St r i ng &) const ;
};

Vase que es posible asignar una cadena " " sin sobrecargar el operador de
asignacin, o comparar un objeto String con una cadena. Esto se logra gracias a
que se provee de un constructor que convierte una cadena a un objeto String. De
esta manera, este constructor de conversin es llamado automticamente, creando
un objeto temporal para ser comparado con el otro objeto.

No es posible que la cadena (o apuntador a char) vaya del lado izquierdo,
pues se estara llamando a la funcionalidad del operador para un apuntador a
char.

- 187 -
Ejemplo: cdigo de String:

/ / Sobr ecar ga de oper ador es. I mpl ement aci n de una cl ase St r i ng


class St r i ng{
/ / oper ador es de i nser ci n y ext r acci n de f l uj o
friend ost r eam&operator << ( ost r eam&, const St r i ng &) ;
friend i st r eam&operator >> ( i st r eam&, St r i ng &) ;
private:
char *s;
int t am;
public:
St r i ng( char * =NULL) ;

St r i ng( const St r i ng &copi a) {
s=NULL;
t am=0;
*this=copi a; / / se val e o no?
}
~St r i ng( ) {
if( s! =NULL)
delete [ ] s;
}

/ / sobr ecar ga de const r uct or de asi gnaci n
const St r i ng &operator =( const St r i ng &) ;

/ / i gual dad
int operator ==( const St r i ng &) const ;

/ / concat enaci n
St r i ng operator +( const St r i ng &) ;

/ / concat enaci n y asi gnaci n
const St r i ng &operator +=( const St r i ng &) ;
- 188 -

St r i ng &copi a ( const St r i ng &) ;

/ / sobr ecar ga de l os cor chet es
char &operator[ ] ( int) ;
};

/ / oper ador es de i nser ci n y ext r acci n de f l uj o
ost r eam& operator<< ( ost r eam&sal i da, const St r i ng &cad) {
sal i da<<cad. s;
return sal i da; / / per mi t e concat enaci n
}

i st r eam&operator >> ( i st r eam&ent r ada, St r i ng &cad) {
char t mp[ 100] ;
ent r ada >> t mp;
cad=t mp; / / usa oper ador de asi gnaci n de St r i ng y const . de
conver si n
return ent r ada; / / per mi t e concat enaci n
}

St r i ng: : St r i ng( char *c) {
if( c==NULL) {
s=NULL;
t am=0;
} else {
t am=st r l en( c) ;
s= new char[ t am+1] ;
st r cpy( s, c) ;
}
}

const St r i ng &St r i ng: : operator =( const St r i ng &c) {
if( this! = &c) { / / ver i f i ca no asi gnar se a si mi smo
if( s! =NULL)
delete [ ] s;
t am=c. t am;
st r cpy( s, c. s) ;
}
- 189 -
return *this; / / per mi t e concat enaci n de asi gnaci ones
}

int St r i ng: : operator ==( const St r i ng &c) const {
return st r cmp( s, c. s) ==0;
}

/ / oper ador de suma r egr esa una copi a de l a suma obt eni da
/ / en un obj et o l ocal .
St r i ng St r i ng: : operator +( const St r i ng &c) {
St r i ng t mp( *this) ;
t mp+=c;
return t mp;
}

const St r i ng &St r i ng: : operator +=( const St r i ng &c) {
char *st r =s, *ct mp= new char [ c. t am+1] ;
st r cpy( ct mp, c. s) ;
t am+=c. t am;
st r cpy( s, st r ) ;
st r cat ( s, ct mp) ;
delete [ ] st r ;
delete [ ] ct mp;
return *this;
}

St r i ng &St r i ng: : copi a ( const St r i ng &c) {
if( this! = &c) { / / ver i f i ca no asi gnar se a si mi smo
if( s! =NULL)
delete [ ] s;
t am=c. t am;
st r cpy( s, c. s) ;
}
return *this; / / per mi t e concat enaci n de asi gnaci ones
}

char &St r i ng: : operator[ ] ( int i ) {
if( i >0 && i <t am)
- 190 -
return s[ i ] ;
return s[ 0] ;
}

int mai n( ) {
St r i ng a( " AAA" ) ;
St r i ng b( " Pr ueba de cadena" ) ;
St r i ng c( b) ;
/ *es un er r or hacer una asi gnaci n si n l i ber ar memor i a.
ese es el pr i nci pal pel i gr o de usar el oper ador
sobr ecar gado por def aul t de asi gnaci n*/
a=b;
b. copi a( " H o l a" ) ;
b=c+c;
b=" nueva" ;
c+=c;
St r i ng d( " nueva cadena" ) ;
d+=" Hol a" ;
St r i ng e;
e=d+" Adi os" ;
d=" coche" ;
int x=0;
x=d==" coche" ; / / Lo cont r ar i o no es vl i do " coche" ==d
char ch;
ch=d[ 7] ;
d[ 2] = X ;
cout <<d<<endl ;
cout <<" I nt r oduce dos cadenas: " ;
ci n>>e>>d;
cout <<" Cadenas: \ n" ;
cout <<e<<endl <<d;
return 0;
}

- 191 -
Sobrecarga de operadores en Ruby

Aunque Ruby no maneja sobrecarga de operaciones si soporta la sobrecarga de
operadores. Para hacerlo simplemente se define un mtodo en la clase, donde el
nombre del mtodo es el nombre del operador que se necesita sobrecargar.

Sintaxis:

def <oper ador >
. . .
end

Operadores que no pueden ser sobrecargados:

=, ! , not , &&, and, | | , or , . , ! =, . . , . . . , : :

La instruccin return puede omitirse en Ruby porque regresa el resultado de la
ultima expresion de una funcin.

Ejemplo:

#programa de ejemplo de sobrecarga de operadores.
class Punt o
attr_reader :x, :y
@x
@y
def i ni t i al i ze x=10, y=10
@x, @y=x, y
end

def + op
return Punt o. new( @x+op. x, @y+op. y)
end

def - ( op)
Punt o. new( @x- op. x, @y- op. y)
end
- 192 -

def * ( f )
t emp=Punt o. new @x*f , @y*f
return t emp
end

def > ( op)
return ( x>p. x && y>p. y) ? true : false
end

def <= ( op)
return ( x<=p. x && y<=p. y) ? true : false
end
end

def pr ueba
a= Punt o. new 1, 1
b= Punt o. new
c= Punt o. new
put s a. x
put s b. x
put s c. x

c=a+b
put s c. x
put s c. y
c+=a
put s c. x
put s c. y
c=a*0. 5
put s c. x
put s c. y
end

pr ueba

Al ser un lenguaje dinmico, el segundo operando queda determinado en tiempo
de ejecucin. Adems al sobrecargar, por ejemplo, el operador +automticamente
queda sobrecargado el operador +=(lo mismo para el resto de las asigmaciones
abreviadas).
- 193 -

Herencia en C++

Introducci n

La herencia es un mecanismo potente de abstraccin que permite compartir
similitudes entre clases manteniendo al mismo tiempo sus diferencias.

Es una forma de reutilizacin de cdigo, tomando clases previamente
creadas y formando a partir de ellas nuevas clases, heredndoles sus atributos y
mtodos. Las nuevas clases pueden ser modificadas agregndoles nuevas
caractersticas.

En C++la clase de la cual se toman sus caractersticas se conoce como clase
base; mientras que la clase que ha sido creada a partir de la clase base se conoce
como clase derivada. Existen otros trminos para estas clases:

Clase base Clase derivada
Superclase Subclase
Clase padre Clase hija

En J ava es ms comn usar el trmino de superclase y subclase.

Una clase derivada es potencialmente una clase base, en caso de ser
necesario.

Cada objeto de una clase derivada tambin es un objeto de la clase base. En
cambio, un objeto de la clase base no es un objeto de la clase derivada.

La implementacin de herencia a varios niveles forma un rbol jerrquico
similar al de un rbol genealgico. Esta es conocida como jerarqua de herencia.

- 194 -
Generalizacin. Una clase base o superclase se dice que es ms general que
la clase derivada o subclase.

Especializacin. Una clase derivada es por naturaleza una clase ms
especializada que su clase base.

Implementacin en C++

La herencia en C++es implementada permitiendo a una clase incorporar a
otra clase dentro de su declaracin.

Sintaxis general:

class <cl aseNueva>: <acceso> <cl aseBase> {
/ / cuer po cl ase nueva
};

Ejemplo:

Una clase vehculo que describe a todos aquellos objetos
vehculos que viajan en carreteras. Puede describirse a partir
del nmero de ruedas y de pasajeros.

De la definicin de vehculos podemos definir objetos ms
especficos (especializados). Por ejemplo la clase camin.

/ / ej empl o 01 de her enci a


class Vehi cul o{
int r uedas;
int pasaj er os;
public:
void set Ruedas( int) ;
int get Ruedas( ) ;
- 195 -
void set Pasaj er os( int) ;
int get Pasaj er os( ) ;
};

void Vehi cul o: : set Ruedas( int num) {
r uedas=num;
}

int Vehi cul o: : get Ruedas( ) {
return r uedas;
}

void Vehi cul o: : set Pasaj er os( int num) {
pasaj er os=num;
}

int Vehi cul o: : get Pasaj er os( ) {
return pasaj er os;
}

/ / cl ase Cami on con her enci a de Veh cul o
class Cami on: public Vehi cul o {
int car ga;
public:
void set Car ga( int) ;
int get Car ga( ) ;
void muest r a( ) ;
};

void Cami on: : set Car ga( int num) {
car ga=num;
}
int Cami on: : get Car ga( ) {
return car ga;
}

void Cami on: : muest r a( ) {
cout <<" Ruedas: " << get Ruedas( ) <<endl ;
cout <<" Pasaj er os: " << get Pasaj er os( ) <<endl ;
- 196 -
cout <<" Capaci dad de car ga: " <<get Car ga( ) <<endl ;
}

int mai n( ) {
Cami on f or d;
f or d. set Ruedas( 6) ;
f or d. set Pasaj er os( 3) ;
f or d. set Car ga( 3200) ;
f or d. muest r a( ) ;
return 0;
}

Control de Acceso a mi embros en C++

Existen tres palabras reservadas para el control de acceso: public, private y
protected. Estas sirven para proteger los miembros de la clase en diferentes
formas.

El control de acceso, como ya se vio anteriormente, se aplica a los mtodos,
atributos, constantes y tipos anidados que son miembros de la clase.

Resumen de tipos de acceso:

Tipo de
acceso
Descripcin
private Un miembro privado nicamente puede ser utilizado por
los mtodos miembro y funciones amigas
27
de la clase
donde fue declarado.
protected Un miembro protegido puede ser utilizado nicamente
por los mtodos miembro y funciones amigas de la clase
donde fue declarado o por los mtodos miembro y
funciones amigas de las clases derivadas.

27
Funciones amiga es un tema que se ver ms adelante.
- 197 -
El acceso protegido es como un nivel intermedio entre el
acceso privado y pblico.
public Un miembro pblico puede ser utilizado por cualquier
mtodo. Una estructura es considerada por C++como
una clase que tiene todos sus miembros pblicos.

Ejemplo:

/ / ej empl o de cont r ol de acceso

class S{
char *f 1( ) ;
int a;
protected:
int b;
int f 2( ) ;
private:
int c;
int f 3( ) ;
public:
int d, f ;
char *f 4( int) ;
};

int mai n( ) {
S obj ;
obj . f 1( ) ; / / er r or
obj . a=1; / / er r or
obj . f 2( ) ; / / er r or
obj . b=2; / / er r or
obj . c=3; / / er r or
obj . f 3( ) ; / / er r or
obj . d=5;
obj . f 4( obj . f ) ;
return 0;
}

- 198 -
Control de acceso en herencia en C++

Hasta ahora se ha usado la herencia con un solo tipo de acceso, utilizando el
especificador public. Los miembros pblicos de la clase base son miembros
pblicos de la clase derivada, los miembros protegidos permanecen protegidos
para la clase derivada.

Ejemplo:

/ / ej empl o de cont r ol de acceso en her enci a

class Base{
int a;
protected:
int b;
public:
int c;
};

class Der i vada: public Base {
void g( ) ;
};

void Der i vada: : g( ) {
a=0; / / er r or , es pr i vado
b=1; / / cor r ect o, es pr ot egi do
c=2; / / cor r ect o, es pbl i co
}

Para accesar a los miembros de una clase base desde una clase derivada, se
pueden ajustar los permisos por medio de un calificador public, private o
protected.

Si una clase base es declarada como pblica de una clase derivada, los
miembros pblicos y protegidos son accesibles desde la clase derivada, no as los
miembros privados.

- 199 -
Si una clase base es declarada como privada de otra clase derivada, los
miembros pblicos y protegidos de la clase base sern miembros privados de la
clase derivada. Los miembros privados de la clase base permanecen inaccesibles.

Si se omite el calificador de acceso de una clase base, se asume por omisin
que el calificador es public en el caso de una estructura y private en el caso de
una clase.

Ejemplo de sintaxis:

class base {
. . .
};

class d1: private base {
. . .
};

class d2: base {
. . .
};

class d3: public base {
. . .
};

Es recomendable declarar explcitamente la palabra reservada private al
tomar una clase base como privada para evitar confusiones:

class x{
public:
F( ) ;
};

class y: x { / / pr i vado por omi si n
. . .
};

- 200 -
void g( y *p) {
p- >f ( ) ; / / er r or
}

Finalmente, si una clase base es declarada como protegida de una clase
derivada, los miembros pblicos y protegidos de la clase base, se convierten en
miembros protegidos de la clase derivada.

Ejemplo:

/ / acceso por her enci a


class X{
protected:
int i ;
int j ;

public:
void pr eg_i j ( ) ;
void pon_i j ( ) ;
};

void X: : pr eg_i j ( ) {
cout << " Escr i ba dos nmer os: " ;
ci n>>i >>j ;
}

void X: : pon_i j ( ) {
cout <<i <<' ' <<j <<endl ;
}

/ / en Y, i y j de X si guen si endo mi embr os pr ot egi dos
/ / Si se l l egar a a cambi ar est e acceso a pr i vat e i y j se
her edar i an como
/ / mi embr os pr i vados de Y, adems de l os mt odos pbl i cos
class Y: public X{
int k;
- 201 -
public:
int pr eg_k( ) ;
void hacer _k( ) ;
};

int Y: : pr eg_k( ) {
return k;
}

void Y: : hacer _k( ) {
k=i *j ;
}

/ / Z t i ene acceso a i y j de X, per o no a k de Y
/ / por que es pr i vat e por omi si n
/ / Si Y her edar a de x como pr i vat e, i y j ser an pr i vados en
Y,
/ / por l o que no podr an ser accesados desde Z
class Z: public Y {
public:
void f ( ) ;
};

/ / Si Y her edar a a X con pr i vat e, est e mt odo ya no
f unci onar a
/ / no se podr a acceder a i ni a j .
void Z: : f ( ) {
i =2;
j =3;
}

/ / si Y her eda de x como pr i vat e, no es posi bl e accesar a l os
mt odos
/ / pbl i cos desde obj et os de Y ni de Z.
int mai n( ) {
Y var ;
Z var 2;

var . pr eg_i j ( ) ;
var . pon_i j ( ) ;
- 202 -

var . hacer _k( ) ;
cout <<var . pr eg_k( ) <<endl ;

var 2. f ( ) ;
var 2. pon_i j ( ) ;
return 0;
}

Manej o de objetos de l a clase base como objetos de una clase deri vada y
viceversa en C++

Un objeto de una clase derivada pblica, puede ser manejado como un
objeto de su clase base. Sin embargo, un objeto de la clase base no es posible
tratarlo de forma automtica como un objeto de clase derivada.

La opcin que se puede utilizar, es enmascarar un objeto de una clase base a
un apuntador de clase derivada. El problema es que no debe ser desreferenciado
(accesado) as, primero se tiene que hacer que el objeto sea referenciado por un
apuntador de su propia clase.

Si se realiza la conversin explcita de un apuntador de clase base - que
apunta a un objeto de clase base- a un apuntador de clase derivada y,
posteriormente, se hace referencia a miembros de la clase derivada, es un error
pues esos miembros no existen en el objeto de la clase base.

Ejemplo :

/ / POI NT. H
/ / cl ase Poi nt

#ifndef POI NT_H_
#define POI NT_H_


- 203 -
class Poi nt {
friend ost r eam&operator<<( ost r eam&, const Poi nt &) ;
public:
Poi nt ( float = 0, float = 0) ;
void set Poi nt ( float, float) ;
float get X( ) const { return x; }
float get Y( ) const { return y; }

protected:
float x, y;
};

#endif / *POI NT_H_*/

/ / POI NT. CPP
#include " poi nt . h"

Poi nt : : Poi nt ( float a, float b) {
x = a;
y = b;
}

void Poi nt : : set Poi nt ( float a, float b) {
x = a;
y = b;
}

ost r eam&operator<<( ost r eam&out put , const Poi nt &p) {
out put << ' [ ' << p. x << " , " << p. y << ' ] ' ;

return out put ;
}

- 204 -
/ / CI RCLE. H
/ / cl ase Ci r cl e
#ifndef CI RCLE_H
#define CI RCLE_H

#include 

class Ci r cl e : public Poi nt { / / Ci r cl e her eda de Poi nt
friend ost r eam&operator<<( ost r eam&, const Ci r cl e &) ;
public:
Ci r cl e( float r = 0. 0, float x = 0, float y = 0) ;

void set Radi us( float) ;
float get Radi us( ) const;
float ar ea( ) const;
protected:
float r adi us;
};

#endif / *CI RCLE_H_*/

/ / CI RCLE. CPP
#include " ci r cl e. h"

Ci r cl e: : Ci r cl e( float r , float a, float b)
: Poi nt ( a, b) / / l l ama al const r uct or de l a cl ase base
{ r adi us = r ; }

void Ci r cl e: : set Radi us( float r ) { r adi us = r ; }

float Ci r cl e: : get Radi us( ) const { return r adi us; }

float Ci r cl e: : ar ea( ) const
{ return 3. 14159 * r adi us * r adi us; }

/ / sal i da en el f or mat o:
/ / Cent er = [ x, y] ; Radi us = #. ##
- 205 -
ost r eam&operator<<( ost r eam&out put , const Ci r cl e &c) {
out put << " Cent er = [ " << c. x << " , " << c. y
<< " ] ; Radi us = " << set i osf l ags( i os: : showpoi nt )
<< set pr eci si on( 2) << c. r adi us;

return out put ;
}

/ / Pr ueba. cpp
/ / Pr obando apunt ador es a cl ase base a apunt ador es a cl ase
der i vada

int mai n( ) {
Poi nt *poi nt Pt r , p( 3. 5, 5. 3) ;
Ci r cl e *ci r cl ePt r , c( 2. 7, 1. 2, 8. 9) ;

cout << " Poi nt p: " << p << " \ nCi r cl e c: " << c << endl ;

/ / Manej a a un Ci r cl e como un Ci r cl e
poi nt Pt r = &c; / / asi gna l a di r ecci on de Ci r cl e a
poi nt Pt r
ci r cl ePt r = ( Ci r cl e *) poi nt Pt r ; / / mascar a de base a
der i vada
cout << " \ nAr ea de c ( vi a ci r cl ePt r ) : "
<< ci r cl ePt r - >ar ea( ) << endl ;

/ / Es r i esgoso manej ar un Poi nt como un Ci r cl e
/ / get Radi us( ) r egr esa basur a
poi nt Pt r = &p; / / asi gna di r ecci on de Poi nt a poi nt Pt r
ci r cl ePt r = ( Ci r cl e *) poi nt Pt r ; / / mascar a de base a
der i vada
cout << " \ nRadi o de obj et o apunt ado por ci r cl ePt r : "
<< ci r cl ePt r - >get Radi us( ) << endl ;

return 0;
}
- 206 -
Constructores de clase base en C++

El constructor de la clase base puede ser llamado desde la clase derivada,
para inicializar los atributos heredados.

Los constructores y operadores de asignacin de la clase base no son
heredados por las clases derivadas. Pero pueden ser llamados por los de la clase
derivada.

Un constructor de la clase derivada llama primero al constructor de la clase
base. Si se omite el constructor de la clase derivada, el constructor por omisin de
la clase derivada llamar al constructor de la clase base.

Los destructores son llamados en orden inverso a las llamadas del
constructor: un destructor de una clase derivada ser llamado antes que el de su
clase base.

Sintaxis:

<cl ase>: : <const r uct or >( <l i st a de ar gument os>) : <contructor de
clase base>(<lista de argumentos sin el tipo>)

Ejemplo:

/ / POI NT. H
#ifndef POI NT_H
#define POI NT_H

class Poi nt {
public:
Poi nt ( float = 0. 0, float = 0. 0) ;
~Poi nt ( ) ;
protected:
float x, y;
};

- 207 -
#endif / *POI NT_H_*/

/ / POI NT. CPP
Poi nt : : Poi nt ( float a, float b) {
x = a;
y = b;

cout << " Const r uct or Poi nt : "
<< ' [ ' << x << " , " << y << ' ] ' << endl ;
}

Poi nt : : ~Poi nt ( ) {
cout << " Dest r uct or Poi nt : "
<< ' [ ' << x << " , " << y << ' ] ' << endl ;
}

/ / CI RCLE. H
#ifndef CI RCLE_H
#define CI RCLE_H


class Ci r cl e : public Poi nt {
public:
Ci r cl e( float r = 0. 0, float x = 0, float y = 0) ;
~Ci r cl e( ) ;
private:
float r adi us;
};

#endif / *CI RCLE_H_*/

/ / CI RCLE. CPP


- 208 -
: Point(a, b) / / l l amada al const r uct or de cl ase base
{
r adi us = r ;

cout << " Const r uct or Ci r cl e: r adi o es "
<< r adi us << " [ " << a << " , " <

int mai n( ) {
/ / Muest r a l l amada a const r uct or y dest r uct or de Poi nt
{
Poi nt p( 1. 1, 2. 2) ;
}

cout << endl ;
Ci r cl e ci r cl e1( 4. 5, 7. 2, 2. 9) ;
cout << endl ;
Ci r cl e ci r cl e2( 10, 5, 5) ;
cout << endl ;
return 0;
}

- 209 -
Redefi ni cin de mtodos en C++

Algunas veces, los mtodos heredados no cumplen completamente la
funcin que quisiramos que realicen en las clases derivadas. Es posible en C++
redefinir un mtodo de la clase base en la clase derivada. Cuando se hace
referencia al nombre del mtodo, se ejecuta le versin de la clase en donde fue
redefinida.

Es posible sin embargo, utilizar el mtodo original de la clase base por
medio del operador de resolucin de alcance.

Se sugiere redefinir mtodos que no vayan a ser empleados en la clase
derivada, inclusive sin cdigo para inhibir cualquier accin que no nos interese
28
.

La redefinicin de mtodos no es una sobrecarga porque se definen exactamente
con la misma firma.

Ejemplo :

/ / EMPLOY. H
#ifndef EMPLOY_H
#define EMPLOY_H


class Empl oyee {
public:
Empl oyee( const char*, const char*) ;
void pr i nt ( ) const;
~Empl oyee( ) ;
private:
char *f i r st Name;
char *l ast Name;
};

28
En teora esto no debera ser necesario anular operaciones si nos apegamos a la regla del 100% (de
conformidad con la definicin)
- 210 -

#endif / *EMPLOY_H_*/

/ / EMPLOY. CPP
#include <asser t . h>
#include " empl oy. h"

Empl oyee: : Empl oyee( const char *f i r st , const char *l ast ) {
f i r st Name = new char[ st r l en( f i r st ) + 1 ] ;
asser t ( f i r st Name ! = 0) ; st r cpy( f i r st Name, f i r st ) ;

l ast Name = new char[ st r l en( l ast ) + 1 ] ;
asser t ( l ast Name ! = 0) ;
st r cpy( l ast Name, l ast ) ;
}

void Empl oyee: : pr i nt ( ) const
{ cout << f i r st Name << ' ' << l ast Name; }

Empl oyee: : ~Empl oyee( ) {
delete [ ] f i r st Name;
delete [ ] l ast Name;
}

/ / HOURLY. H
#ifndef HOURLY_H
#define HOURLY_H

#include " empl oy. h"

class Hour l yWor ker : public Empl oyee {
public:
Hour l yWor ker ( const char*, const char*, float, float) ;
float get Pay( ) const;
void print() const;
private:
float wage;
float hour s;
- 211 -
};

#endif / *HOURLY_H_*/

/ / HOURLY_B. CPP
#include " hour l y. h"

Hour l yWor ker : : Hour l yWor ker ( const char *f i r st , const char
*l ast , float i ni t Hour s, float i ni t Wage) : Empl oyee( f i r st ,
l ast ) {
hour s = i ni t Hour s;
wage = i ni t Wage;
}

float Hour l yWor ker : : get Pay( ) const { return wage * hour s; }

void HourlyWorker::print() const {
cout << " Hour l yWor ker : : pr i nt ( ) \ n\ n" ;

Employee::print(); / / l l ama a f unci n de cl ase base

cout << " es un t r abaj ador por hor a con suel do de"
<< " $" << set i osf l ags( i os: : showpoi nt )
<< set pr eci si on( 2) << get Pay( ) << endl ;
}

/ / mai n. CPP
#include " hour l y. h"

int mai n( ) {
Hour l yWor ker h( " Bob" , " Smi t h" , 40. 0, 7. 50) ;
h. pr i nt ( ) ;
return 0;
}

- 212 -
Herencia Mltipl e en C++

Una clase puede heredar miembros de ms de una clase; lo que se conoce
como herencia mltiple.

Herencia mltiple es entonces, la capacidad de una clase derivada de
heredar miembros de varias clases base.

Sintaxis:

class <nombr e cl ase der i vada> : <clase base 1> , <clase base
2>, ...<clase base n> {
. . .
};

Ejemplo:

class A{
public:
int i ;
void a( ) {}
};

class B{
public:
int j ;
void b( ) {}
};

class C{
public:
int k;
void c( ) {}
};

- 213 -
class D: public A, public B, public C {
public:
int l ;
void d( ) {}
};

int mai n( ) {
D var 1;

var 1. a( ) ;
var 1. b( ) ;
var 1. c( ) ;
var 1. d( ) ;
return 0;
}

Otro ejemplo :

/ / BASE1. H
#ifndef BASE1_H
#define BASE1_H

class Base1 {
public:
Base1( int x) { val ue = x; }
int get Dat a( ) const { return val ue; }
protected:
int val ue;
};

#endif / *BASE1_H_*/

- 214 -
/ / BASE2. H
#ifndef BASE2_H
#define BASE2_H

class Base2 {
public:
Base2( char c) { l et t er = c; }
char get Dat a( ) const { return l et t er ; }
protected:
char l et t er ;
};

#endif / *BASE2_H_*/

/ / DERI VED. H
#ifndef DERI VED_H
#define DERI VED_H

/ / her enci a ml t i pl e
class Der i ved : public Base1, public Base2 {
friend ost r eam&operator<<( ost r eam&, const Der i ved &) ;
public:
Der i ved( int, char, float) ;
float get Real ( ) const;
private:
float r eal ;
};

#endif / *DERI VED_H_*/

/ / DERI VED. CPP
#include " base1. h"
#include " der i ved. h"

Der i ved: : Der i ved( int i , char c, float f ) : Base1( i ) , Base2( c) {
r eal = f ;
}

- 215 -
float Der i ved: : get Real ( ) const {
return r eal ;
}

ost r eam&operator<<( ost r eam&out put , const Der i ved &d) {
out put << " Ent er o: " << d. val ue
<< " \ n Car act er : " << d. l et t er
<< " \ nNmer o r eal : " << d. r eal ;

return out put ;
}

/ / mai n. CPP
#include " der i ved. h"

int mai n( ) {
Base1 b1( 10) , *base1Pt r ; Base2 b2( ' Z' ) , *base2Pt r ;
Der i ved d( 7, ' A' , 3. 5) ;
cout << " Obj et o b1 cont i ene ent er o "
<< b1. get Dat a( )
<< " \ nObj et o b2 cont i ene car act er "
<< b2. get Dat a( )
<< " \ nObj et o d cont i ene: \ n" << d;
cout << " \ n\ nmi embr os de cl ase der i vada pueden ser "
<< " accesados i ndi vi dual ment e: "
<< " \ n Ent er o: " << d. Base1: : get Dat a( )
<< " \ n Car act er : " << d. Base2: : get Dat a( )
<< " \ n Nmer o r eal : " << d. get Real ( ) << " \ n\ n" ;
/ / Pr obar : cout<<d.getData(); Es un er r or ?
cout << " Mi embr os der i vados pueden ser t r at ados como "
<< " obj et os de su cl ase base: \ n" ;

base1Pt r = &d;
cout << " base1Pt r - >get Dat a( ) "
<< base1Pt r - >get Dat a( ) ;

base2Pt r = &d;
- 216 -
cout << " \ nbase2Pt r - >get Dat a( ) "
<< base2Pt r - >get Dat a( ) << endl ;
return 0;
}

Aqu se tiene un problema de ambigedad al heredar dos mtodos con el
mismo nombre de clases diferentes. Se resuelve poniendo antes del nombre del
miembro el nombre de la clase: objeto.<clase::>miembro. El nombre del objeto
es necesario pues no se esta haciendo referencia a un miembro esttico.
Ambigedades

En el ejemplo anterior se vio un caso de ambigedad al heredar de clases
distintas un miembro con el mismo nombre. Normalmente se deben tratar de
evitar esos casos, pues vuelven confuso nuestra jerarqua de herencia.

Existen otro casos donde es posible que se de la ambigedad.

Ejemplo:

/ / ej empl o de ambi gedad en l a her enci a
class B{
public:
int b;
};

class D: public B, public B { / / er r or
};

void f ( D *p) {
p- >b=0; / / ambi guo
}

int mai n( ) {
D obj ;
f ( &obj ) ;
return 0;
}
- 217 -

El cdigo anterior tiene un error en la definicin de herencia mltiple, ya
que no es posible heredar ms de una vez una misma clase de manera directa. Sin
embargo, si es posible heredar las caractersticas de una clase ms de una vez
indirectamente:

/ / ej empl o de ambi gedad en l a her enci a


class A{
public:
int next ;
};

class B: public A{
};

class C: public A{
};

class D: public B, public C {
int g( ) ;
};

int D: : g( ) {
- 218 -
/ / next =0; Er r or : asi gnaci n ambi gua
return B: : next == C: : next ;
}

class E: public D{
public:
int x;
int get x( ) {
return x;
}
};

int mai n( ) {
D obj ;
E obj e;

obj . B::next=10;
obj . C::next=20;
/ / obj . A: : next =11; Er r or : acceso ambi guo
/ / obj . next =22; Er r or : acceso ambi guo
cout <<" next de B: " <<obj . B: : next <<endl ;
cout <<" next de C: " <<obj . C: : next <<endl ;

obj e. x=0;
obj e. B: : next =11;
obj e. C: : next =22;
cout <<" obj e next de B: " <<obj e. B: : next <<endl ;
cout <<" obj e next de C: " <<obj e. C: : next <<endl ;
return 0;
}

Este programa hace que las instancias de la clase D tengan objetos de clase
base duplicados y provoca los accesos ambiguos. Este problema se resuelve con
herencia virtual.

Herencia de clase base virtual: Si se especifica a una clase base como
virtual, solamente un objeto de la clase base existir en la clase derivada.

- 219 -
Para el ejemplo anterior, las clases B y C deben declarar a la clase A como
clase base virtual:

cl ass B: vi r t ual publ i c A {. . . }

cl ass C: vi r t ual publ i c A {. . . }

El acceso entonces a los miembros puede hacerse usando una de las clases
de las cuales heredo el miembro:

obj . B: : next =10;
obj . C: : next =20;

O simplemente accediendolo como un miembro no ambiguo:

obj . next =22;

En cualquier caso se tiene solo una copia del miembro, por lo que cualquier
modificacin del atributo next es sobre una nica copia del mismo.
- 220 -

Constructores en herencia mltiple

Si hay constructores con argumentos, es posible que sea necesario llamarlos
desde el constructor de la clase derivada. Para ejecutar los constructores de las
clases base, pasando los argumentos, es necesario especificarlos despus de la
declaracin de la funcin de construccin de la clase derivada, separados por
coma.

Sintaxis general:

<Const r uct or cl ase der i vada>( <ar gument os> : <base1>
(<argumentos>), <base2> (<argumentos>), ... , <basen>
(<argumentos>) {
. . .
}

donde como en la herencia simple, el nombre base corresponde al nombre de la
clase, o en este caso, clases base.

El orden de llamada a constructores de las clases base se puede alterar a
conveniencia. Una excepcin a considerar es cuando se recuelve ambigedad de
una clase base pues en ese caso el constructor de la clase base ambigua
nicamente se ejecuta una vez. Si no es especificado por el programador, se
ejecuta el constructor sin parmetros de la clase base ambigua. Si se requiere
pasar parmetros, se debe especificar la llamada antes de las llamadas a
constructores de clase base directas. Este es el nico caso en que es posible llamar
a un constructor de una clase que no es un ancestro directo [7].

- 221 -
Herencia en Java

La clase de la cual se toman sus caractersticas se conoce como superclase;
mientras que la clase que ha sido creada a partir de la clase base se conoce como
subclase.

Implementacin en Java

La herencia en J ava difiere ligeramente de la sintaxis de implementacin de
herencia en C++.

Sintaxis general:

class cl aseNueva extends superclase {
/ / cuer po cl ase nueva
}

Ejemplo:

Una clase vehculo que describe a todos aquellos objetos
vehculos que viajan en carreteras. Puede describirse a partir
del nmero de ruedas y de pasajeros.

De la definicin de vehculos podemos definir objetos ms
especficos (especializados). Por ejemplo la clase camin.

/ / ej empl o de her enci a

class Vehi cul o{
private int r uedas;
private int pasaj er os;

public void set Ruedas( int num) {
r uedas=num;
}

- 222 -
public int get Ruedas( ) {
return r uedas;
}

public void set Pasaj er os( int num) {
pasaj er os=num;
}

public int get Pasaj er os( ) {
return pasaj er os;
}

}

/ / cl ase Cami on con her enci a de Vehi cul o
public class Cami on extends Vehi cul o {
private int car ga;

public void set Car ga( int num) {
car ga=num;
}

public int get Car ga( ) {
return car ga;
}

public void muest r a( ) {
/ / uso de mt odos her edados
Syst em. out . pr i nt l n( " Ruedas: " + getRuedas( ) ) ;
Syst em. out . pr i nt l n( " Pasaj er os: " + getPasajeros( ) ) ;
/ / mt odo de l a cl ase Cami on
Syst em. out . pr i nt l n( " Capaci dad de car ga: " +
get Car ga( ) ) ;
}

public static void mai n( St r i ng ar gvs[ ] ) {
Cami on f or d= new Cami on( ) ;
f or d. setRuedas( 6) ;
f or d. setPasajeros( 3) ;
f or d. set Car ga( 3200) ;
- 223 -
f or d. muest r a( ) ;
}

}

En el programa anterior se puede apreciar claramente como una clase
Vehculo hereda sus caractersticas a la subclase Camion, pudiendo este ltimo
aprovechar recursos que no declara en su definicin.

BlueJ

BlueJ es un programa desarrollado por la universidades de Kent y Deakin para
ayudar a los estudiantes a entender programacin orientada a objetos en J ava,
particularmente ayuda a entender la herencia.

A partir de un diagrama de clases, BlueJ puede generar el cdigo bsico de la
clase en J ava, el cul puede ser editado y compilado conforme las necesidades del
programa. El programa es bsico y fcil de usar permitiendo entender estructuras
complejas en las relaciones de herencia.

- 224 -
El cdigo J ava generado por BlueJ para el diagrama de la figura anterior es el
siguiente:

/ **
* Wr i t e a descr i pt i on of cl ass Vehi cul o her e.
*
* @author ( your name)
* @version ( a ver si on number or a dat e)
*/
public class Vehi cul o
{
/ / i nst ance var i abl es - r epl ace t he exampl e bel ow wi t h
your own
private int x;

/ **
* Const r uct or f or obj ect s of cl ass Vehi cul o
*/
public Vehi cul o( )
{
/ / i ni t i al i se i nst ance var i abl es
x = 0;
}

/ **
* An exampl e of a met hod - r epl ace t hi s comment wi t h your
own
*
* @param y a sampl e par amet er f or a met hod
* @return t he sumof x and y
*/
public int sampl eMet hod( int y)
{
/ / put your code her e
return x + y;
}
}

- 225 -
/ **
* Wr i t e a descr i pt i on of cl ass Cami on her e.
*
* @author ( your name)
* @version ( a ver si on number or a dat e)
*/
public class Cami on extends Vehi cul o
{
/ / i nst ance var i abl es - r epl ace t he exampl e bel ow wi t h
your own
private int x;

/ **
* Const r uct or f or obj ect s of cl ass Cami on
*/
public Cami on( )
{
/ / i ni t i al i se i nst ance var i abl es
x = 0;
}

/ **
* An exampl e of a met hod - r epl ace t hi s comment wi t h your
own
*
* @param y a sampl e par amet er f or a met hod
* @return t he sumof x and y
*/
public int sampl eMet hod( int y)
{
/ / put your code her e
return x + y;
}
}
- 226 -

Clase Object

En J ava toda clase que se define tiene herencia implcita de una clase
llamada object. En caso de que la clase que crea el programador defina una
herencia explcita a una clase, hereda las caractersticas de la clase Object de
manera indirecta
29
.

A continuacin se presenta la informacin general de la clase Object
30
:

Class Object
java.lang.Object

public class Object
Class Obj ect is the root of the class hierarchy. Every class has Obj ect as a superclass. All objects, including
arrays, implement the methods of this class.
Since:
J DK1.0
See Also:
Cl ass

Constructor Summary
Object( )

Method Summary
pr ot ect ed
Obj ect
clone( )
Creates and returns a copy of this object.
bool ean equals( Obj ect obj )
Indicates whether some other object is "equal to" this one.

29
En este caso hay quye considerar que las caractersticas de la clase Object pudieron haber sido modificadas
a travs de la jerarqua de herencia.
30
Tomada de la documentacin del jdk 1.6
- 227 -
pr ot ect ed
voi d
finalize( )
Called by the garbage collector on an object when garbage
collection determines that there are no more references to the object.
Cl ass<?> getClass( )
Returns the runtime class of an object.
i nt hashCode( )
Returns a hash code value for the object.
voi d notify( )
Wakes up a single thread that is waiting on this object's monitor.
voi d notifyAll( )
Wakes up all threads that are waiting on this object's monitor.
St r i ng toString( )
Returns a string representation of the object.
voi d wait( )
Causes current thread to wait until another thread invokes the
not i f y( ) method or the not i f yAl l ( ) method for this object.
voi d wait( l ong t i meout )
Causes current thread to wait until either another thread invokes
the not i f y( ) method or the not i f yAl l ( ) method for this object, or a
specified amount of time has elapsed.
voi d wait( l ong t i meout , i nt nanos)
Causes current thread to wait until another thread invokes the
not i f y( ) method or the not i f yAl l ( ) method for this object, or some other
thread interrupts the current thread, or a certain amount of real time has
elapsed.

Control de acceso a miembros en Java

Existen tres palabras reservadas para el control de acceso a los miembros de
una clase: public, private y protected. Estas sirven para proteger los miembros de
la clase en diferentes formas.

El control de acceso, como ya se vio anteriormente, se aplica a los mtodos,
atributos, constantes y tipos anidados que son miembros de la clase.

- 228 -

Tipo de
acceso
Descripcin
private Un miembro privado nicamente puede ser utilizado por
los mtodos miembro de la clase donde fue declarado.
Un miembro privado no es posible que sea manejado ni
siquiera en sus subclases.
protected Un miembro protegido puede ser utilizado nicamente
por los mtodos miembro de la clase donde fue
declarado, por los mtodos miembro de las clases
derivadas clases que pertenecen al mismo paquete.
El acceso protegido es como un nivel intermedio entre el
acceso privado y pblico.
public Un miembro pblico puede ser utilizado por cualquier
mtodo. Este es visible en cualquier lugar que la clase
sea visible

Ejemplo:

/ / ej empl o de cont r ol de acceso

class Acceso{
protected int b;
protected int f 2( ) {
return b;
}

private int c;
private int f 3( ) {
return c;
}

public int d, f ;
public int f 4( ) {
return d;
}
- 229 -

}

public class Ej empl oAcceso {

Acceso obj = new Acceso( ) ;

obj . f 2( ) ; / / es vl i do, ya que por omi si n
obj . b=2; / / l as dos cl ases est n en el mi smo paquet e

obj . c=3; / / er r or es un at r i but o pr i vado
obj . f 3( ) ; / / er r or es un mt odo pr i vado

obj . d=5;
obj . f 4( ) ;
}
}

El ejemplo anterior genera errores de compilacin al tratar de acceder desde
otra clase a miembros privados. Sin embargo, los miembros protegidos si pueden
ser accesados porque estn considerados implcitamente dentro del mismo
paquete.
- 230 -

Control de acceso de clase publ ic en Java

Este controlador de acceso public, opera a nivel de la clase para que esta se
vuelva visible y accesible desde cualquier lugar, lo que permitira a cualquier otra
clase hacer uso de los miembros de la clase pblica.

public class TodosMeVen {

/ / def i ni ci n de l a cl ase

}

La omisin de este calificador limita el acceso a la clase para que solo sea
utilizada por clases pertenecientes al mismo paquete.

Adems, se ha mencionado que en un archivo fuente nicamente puede
existir una clase pblica, la cual debe coincidir con el nombre del archivo. La
intencin es que cada clase que tenga un objetivo importante debera ir en un
archivo independiente, pudiendo contener otras clases no pblicas que le ayuden
a llevar a cabo su tarea.

Constructores de superclase

Los constructores no se heredan a las subclases. El constructor de la
superclase puede ser llamado desde la clase derivada, para inicializar los atributos
heredados y no tener que volver a introducir cdigo de inicializacin ya escrito en
la superclase.

La llamada explcita al constructor de la superclase se realiza mediante la
referencia super seguida de los argumentos si los hubiera- del constructor de la
clase base. La llamada a este constructor debe ser hecha en la primera lnea del
constructor de la subclase. Si no se introduce as, el constructor de la clase
- 231 -
derivadada llamar automticamente al constructor por omisin (sin parmetros)
de la superclase.

En el ejemplo siguiente podr apreciarse esta llamada al constructor de la
superclase.

Manej o de objetos de l a subcl ase como obj etos de una superclase en Java

Un objeto de una clase derivada, puede ser manejado como un objeto de su
superclase. Sin embargo, un objeto de la clase base no es posible tratarlo como un
objeto de clase derivada.

Un objeto de una subclase puede ser asignado a una variable de referencia
de su superclase sin necesidad de indicar una conversin explcita mediante
enmascaramiento. Cuando si se necesita utilizar enmascaramiento es para asignar
de vuelta un objeto que aunque sea de una clase derivada, este referenciado por
una variable de clase base. Esta conversin explcita es verificada por la mquina
virtual, y si no corresponde el tipo real del objeto, no se podr hacer la asignacin
y se generar una excepcin en tiempo de ejecucin.

Ejemplo:

Super cl ase s= new super cl ase( ) , apt Super ;
Subcl ase sub= new subcl ase( ) , apt Sub;

/ / vl i do
apt Super = sub;

apt Sub = ( Subcl ase) apt Super ;

/ / i nvl i do
apt Sub= ( Subcl ase) s;

Podemos ver en el ejemplo anterior, que un objeto puede navegar en la
jerarqua de clases hacia sus superclases, pero no puede ir a una de sus subclases,
- 232 -
ni utilizando el enmascaramiento. Esto se hace por seguridad, ya que la subclase
seguramente contendr un mayor nmero de elementos que una instancia de
superclase y estos no podran ser utilizados porque causaran una inconsistencia.

Por ltimo, es importante sealar que mientras un objeto de clase derivada
este referenciado como un objeto de superclase, deber ser tratado como si el
objeto fuera nicamente de la superclase; por lo que no podr en ese momento
tener referencias a atributos o mtodos definidos en la clase derivada.

Un ejemplo completo se muestra a continuacin:

/ / def i ni ci on de cl ase poi nt
public class Poi nt {
protected double x, y; / / coor denadas del punt o

/ / const r uct or
public Poi nt ( double a, double b ) {
set Poi nt ( a, b ) ;
}

/ / asi gna a x, y l as coor denadas del punt o
public void set Poi nt ( double a, double b ) {
x = a;
y = b;
}

/ / obt i ene coor denada x
public double get X( ) {
return x;
}

/ / obt i ene coor denada y
public double get Y( ) {
return y;
}

/ / convi er t e i nf or maci on a cadena
public St r i ng t oSt r i ng( ) {
- 233 -
return " [ " + x + " , " + y + " ] " ;
}
}

/ / Def i ni ci on de cl ase ci r cul o

public class Ci r cl e extends Poi nt { / / Her eda de Poi nt
protected double r adi us;

/ / const r uct or si n ar gument os
public Ci r cl e( ) {
super( 0, 0 ) ; / / l l amada a const r uct or de cl ase base
set Radi us( 0 ) ;
}

/ / Const r uct or
public Ci r cl e( double r , double a, double b ) {
super( a, b ) ; / / l l amada a const r uct or de cl ase base
set Radi us( r ) ;
}

/ / Asi gna r adi o del ci r cul o
public void set Radi us( double r )
{ r adi us = ( r >= 0. 0 ? r : 0. 0 ) ; }

/ / Obt i ene r adi o del ci r cul o
public double get Radi us( ) { return r adi us; }

/ / Cal cul o ar ea del ci r cul o
public double ar ea( ) { return 3. 14159 * r adi us * r adi us; }

/ / Convi er t e i nf or maci on en cadena
return " Cent r o = " + " [ " + x + " , " + y + " ] " +
" ; Radi o = " + r adi us;
}
}

- 234 -
/ / Cl ase de Pr ueba de l as cl ases Poi nt y Ci r cl e

public class Pr ueba {

Poi nt poi nt Ref , p;
Ci r cl e ci r cl eRef , c;

p = new Poi nt ( 3. 5, 5. 3 ) ;
c = new Ci r cl e( 2. 7, 1. 2, 8. 9 ) ;

Syst em. out. pr i nt l n( " Punt o p: " + p. t oSt r i ng( ) ) ;
Syst em. out. pr i nt l n( " Ci r cul o c: " + c. t oSt r i ng( ) ) ;

/ / Tr at ami ent o del ci r cul o como i nst anci a de punt o
poi nt Ref = c; / / asi gna ci r cul o c a poi nt Ref
/ / en r eal i dad J ava l o r econoce di nmi cament e como
obj et o Ci r cl e
Syst em. out. pr i nt l n( " Ci r cul o c ( vi a poi nt Ref ) : " +
poi nt Ref . t oSt r i ng( ) ) ;

/ / Manej ar a un ci r cul o como ci r cul o ( obt eni endol o de
una r ef er enci a de punt o)
poi nt Ref = c; / / asi gna ci r cul o c a poi nt r ef . Se
r epi t e l a oper aci on por cl ar i dad
ci r cl eRef = ( Circle) poi nt Ref ; / / enmascar ami ent o de
super cl ase a subcl ase
Syst em. out. pr i nt l n( " Ci r cul o c ( vi a ci r cl eRef ) : " +
ci r cl eRef . t oSt r i ng( ) ) ;
Syst em. out. pr i nt l n( " Ar ea de c ( vi a ci r cl eRef ) : " +
ci r cl eRef . ar ea( ) ) ;

/ / i nt ent o de r ef er enci ar a un obj et o poi nt
/ / desde una r ef er enci a de Ci r cl e ( genera una excepcion)
ci r cl eRef = ( Circle) p;
}
}

- 235 -
Redefi ni cin de mtodos

Algunas veces, los mtodos heredados no cumplen completamente la
funcin que queremos que realicen en la subclase. Por esta razn, J ava permite
redefinir un mtodo de la clase base en la clase derivada. Cuando se hace
referencia al nombre del mtodo, se ejecuta la versin de la clase en donde fue
redefinida. Es posible sin embargo, utilizar el mtodo de la clase base por medio
del la referencia super.

De hecho, se sugiere redefinir mtodos que no vayan a ser empleados en la
clase derivada, inclusive sin cdigo para inhibir cualquier accin que no nos
interese en la clase derivada.

Ejemplo:

/ / cl ase empl eado
public class Empl eado {

private St r i ng f i r st Name, l ast Name;

public Empl eado( St r i ng f i r st , St r i ng l ast ) {
f i r st Name = new St r i ng( f i r st ) ;
l ast Name = new St r i ng( l ast ) ;
}

public void pr i nt ( ) {
Syst em. out. pr i nt l n( f i r st Name + ' ' + l ast Name) ;
}

}

/ / cl ase Tr abaj ador por Hor a
public class Tr abaj ador Por Hor a extends Empl eado {
private float wage, hour s;
public Tr abaj ador Por Hor a( St r i ng f i r st , St r i ng l ast , float
i ni t Hour s, float i ni t Wage) {
super( f i r st , l ast ) ;
hour s = i ni t Hour s;
- 236 -
wage = i ni t Wage;
}

public float get Pay( ) {
return wage * hour s;
}

public void print( ) {
Syst em. out. pr i nt l n( " Met odo pr i nt de Tr abaj ador por
hor a" ) ;

super. print( ) ; / / l l ama a f unci n de cl ase base

Syst em. out. pr i nt l n( " es un t r abaj ador por hor a con
suel do de" +
" $" + get Pay( ) ) ;
}
}

/ / cl ase de pr ueba EmpTest

public class EmpTest {

Empl eado e= new Empl eado ( " nombr e" , " apel l i do" ) ;
Tr abaj ador Por Hor a h;

h=new Tr abaj ador Por Hor a ( " J uani t o" , " Per ez" , 40. 0f ,
7. 50f ) ;
e. pr i nt ( ) ;
h. pr i nt ( ) ;
}
}

- 237 -
Calificador fi nal

Es posible que tengamos la necesidad de que cierta parte de una clase no
pueda ser modificada en futuras extensiones de la jerarqua de herencia. Para esto
es posible utilizar el calificador final.

Si un mtodo se especifica en una clase X como final:

<acceso> final <t i po> nombr eMt odo( <par met r os>)

Se esta diciendo que el mtodo no podr ser redefinido en las subclases de
X.

Aunque se omita este calificador, si se trata de un mtodo de clase (esttico)
o privado, se considera final y no podr ser redefinido.

Por otro lado, es posible que no queramos dejar la posibilidad de extender
una clase, para lo que se utiliza el calificador final a nivel de clase:

<acceso> final class nombr eCl ase {


}
De esta forma, la clase no permite generar subclases a partir de ella. De
hecho, el API de J ava incluye muchas clases final, por ejemplo la clase
java.lang.String no puede ser especializada.

- 238 -
Interfaces

J ava nicamente cuenta con manejo de herencia simple, y la razn que se
ofrece es que la herencia mltiple presenta algunos problemas de ambigedad que
complica el entendimiento del programa, sin que este tipo de herencia justifique
las ventajas obtenidas de su uso.

Sin embargo, es posible que se necesiten recibir caractersticas de ms de un
origen. J ava soluciona esto mediante el uso de interfaces, que son una forma para
declarar tipos especiales de clase que, aunque con ciertas limitaciones, no ofrecen
las complicaciones de la herencia mltiple.

Una interfaz tiene un formato muy similar a una clase, sus principales
caractersticas:

Una interfaz proporciona los nombres de los mtodos, pero no sus
implementacines.
31

Una clase puede implementar varias interfaces, aunque solo pueda heredar
una clase.

No es posible crear instancias de una interfaz.

La clase que implementa la interfaz debe escribir el cdigo de todos los
mtodos, de otra forma no se podr generar instancias de esa clase.

El formato general para la declaracin de una interfaz es el siguiente:

[ public] interface <nombr eI nt er f az> {
/ / descr i pci n de mi embr os
/ / l os mt odos no i ncl uyen cdi go:
<acceso> <t i po> <nombr eMet odo> ( <par met r os> ) ;
}

31
En esta caso si se considera la declaracin de prototipos.
- 239 -

El cuerpo de la interfaz generalmente es una lista de prototipos de mtodos,
pero puede contener atributos si se requiere
32
.

Una clase implementa una interfaz a travs de la palabra reservada
implements despus de la especificacin de la herencia (si la hubiera) :

class <nombr eCl ase> extends <Super cl ase> implements
<nombr eI nt er f az> {

/ / debe i ncl ui r se l a def i ni ci n de l os mt odos de l a
i nt er f az
/ / con l a i mpl ement aci n del cdi go de di chos mt odos.
}

Adems, una interfaz puede ser extendida de la misma forma que una clase,
aprovechando las interfaces previamente definidas, mediante el uso de la clasula
extends.

[ public] interface <nombr eI nt er f az> extends {

/ / descr i pci n de mi embr os

}

De forma distinta a la jerarqua de clases, donde se tiene una jerarqua lineal
que parte siempre de una clase simple Object, una clase soporta herencia mltiple
de interfaces, resultando en una jerarqua con multiples raices de diferentes
interfaces.

Ejemplo:

/ / i nt er f az
interface I St ack {
void push( Obj ect i t em) ;

32
El parmetro debe incluir el nombre, el cual no es obligatorio que coincida en la implementacin.
- 240 -
Obj ect pop( ) ;
}

/ / cl ase i mpl ement a l a i nt er f az
class St ackI mpl implements I St ack {
protected Obj ect [ ] st ackAr r ay;
protected int t os;

public St ackI mpl ( int capaci t y) {
st ackAr r ay = new Obj ect [ capaci t y] ;
t os = - 1;
}

/ / i mpl ement a el mt odo def i ni do en l a i nt er f az
public void push( Obj ect i t em)
{ st ackAr r ay[ ++t os] = i t em; }

/ / i mpl ement a el mt odo def i ni do en l a i nt er f az
public Obj ect pop( ) {
Obj ect obj Ref = st ackAr r ay[ t os] ;
st ackAr r ay[ t os] = null;
t os- - ;
return obj Ref ;
}

public Obj ect peek( ) { return st ackAr r ay[ t os] ; }
}

/ / ext endi endo una i nt er f az
interface I Saf eSt ack extends I St ack {
boolean i sEmpt y( ) ;
boolean i sFul l ( ) ;
}

- 241 -
/ / est a cl ase her eda l a i mpl ement aci n de l a pi l a St ackI mpl
/ / e i mpl ement a l a nueva i nt er f az ext endi da I Saf eSt ack
class Saf eSt ackI mpl extends St ackI mpl implements I Saf eSt ack {

public Saf eSt ackI mpl ( int capaci t y) { super( capaci t y) ; }

/ / i mpl ement a l os mt odos de l a i nt er f az
public boolean i sEmpt y( ) { return t os < 0; }
public boolean i sFul l ( ) { return t os >= st ackAr r ay. l engt h;
}
}

public class St ackUser {

Saf eSt ackI mpl saf eSt ackRef = new Saf eSt ackI mpl ( 10) ;
St ackI mpl st ackRef = saf eSt ackRef ;
I Saf eSt ack i saf eSt ackRef = saf eSt ackRef ;
I St ack i st ackRef = saf eSt ackRef ;
Obj ect obj Ref = saf eSt ackRef ;

saf eSt ackRef . push( " Dol ar " ) ;
st ackRef . push( " Peso" ) ;
Syst em. out. pr i nt l n( i saf eSt ackRef . pop( ) ) ;
Syst em. out. pr i nt l n( i st ackRef . pop( ) ) ;

Syst em. out. pr i nt l n( obj Ref . get Cl ass( ) ) ;
}
}

- 242 -
IStack
push()
pop()
<<Interface>>
Object
StackImpl
push()
pop()
SafeStack
isFull()
isEmpty()

Por otro lado, una interfaz tambien puede ser utilizada para definir nuevos
tipos. Una interfaz as o una clase que implementa a una interfaz de este estilo es
conocida como Supertipo.

Es importante resaltar tres diferencias en las relaciones de herencia y como
esta funciona entre clases e interfaces:

1. Implementacin lineal de jerarqua de herencia entre clases: una clase
extiende a otra clase.

2. Jerarqua de herencia mltiple entre interfaces: una interfaz extiende
otras interfaces.

3. Jerarqua de herencia mltiple entre interfaces y clases: una clase
implementa interfaces.

- 243 -

Herencia en Ruby

Implementacin en Ruby

Ruby, al igual que J ava, no cuenta con herencia mltiple, por lo que
nicamente es posible indicar una clase como superclase. Para esto se utiliza el
smbolo <antes del nombre de la superclase.

Sintaxis:

class I dent i f i cador Cl ase < Super Cl ase
<expr esi n>
end

Ejemplo:
Retomando el ejemplo del la jerarqua de Vehculo y Camin, visto en la seccin
de herencia en J ava.

# ejemplo de herencia
class Vehi cul o
@r uedas
@pasaj er os
attr_accessor :ruedas, :pasajeros
end

# clase Camion con herencia de Vehiculo
class Cami on < Vehi cul o
@car ga
attr_accessor :carga

public
def muest r a
# uso de mtodos heredados y generados automaticamente
por attr_accessor
put s " Ruedas: #{r uedas}"
- 244 -
put s " Pasaj er os: #{pasaj er os}"
# mtodo de la clase Camion
put s " Capaci dad de car ga: #{car ga}"
end
end

# Cdigo de prueba
f or d= Cami on. new
f or d. r uedas =6
f or d. pasaj er os=3
f or d. car ga=3200
f or d. muest r a

Clase Cl ass

Las clases en Ruby son considerados objetos de primera clase
33
. Cada clase
declarada en Ruby es una instancia de la clase Class [12].

El proceso que se sigue es el siguiente: cuando una clase es definida, un objeto de
la clase Class es creado y asignado a una constante global con el nombre de usado
en la definicin. Cuando un nuevo objeto de la clase es instanciado
(nombreClase.new), el mtodo new de Class es ejecutado por omisin.
34

A continuacin se presenta la informacin general de la clase Class [12]:

class methods
inherited aClass.inherited( aSubClass )
This is a singleton method (per class) invoked by Ruby when a subclass of
aClass is created. The new subclass is passed as a parameter.

cl ass Top
def Top. i nher i t ed( sub)
pr i nt " New subcl ass: " , sub, " \ n"
end

33
Pueden ser usados en el lengauje de programacin como cualquier otro objeto.
34
De hecho, el mtodo new de la clase Class puede ser redefinido, aunque no es una prctica recomendada.
- 245 -
end

cl ass Mi ddl e < Top
end

cl ass Bot t om< Mi ddl e
end

produces:

New subcl ass: Mi ddl e
New subcl ass: Bot t om

new Class.new( aSuperClass=Object ) -> aClass
Creates a new anonymous (unnamed) class with the given superclass (or
Object if no parameter is given).

instance methods
new aClass.new( [ args ]* ) -> anObject
Creates a new object of aClass's class, then invokes that object's initialize
method, passing it args.

superclass aClass.superclass -> aSuperClass or nil
Returns the superclass of aClass, or nil.

Cl ass. super cl ass Modul e
Obj ect . super cl ass ni l

Clase Object

La clase padre de todas las clases en Ruby es la clase Object, por lo que sus
mtodos estn disponibles para todos los objetos a menos que estos se encuentren
redefinidos.

A contianuacin se presenta una lista de los mtodos de Object:

- 246 -
== === =~ __i d__ __send__ cl ass cl one dcl one
di spl ay dup enum_f or eql ? equal ? ext end f r eeze
f r ozen? hash i d i nspect i nst ance_eval i nst ance_of ?
i nst ance_var i abl e_def i ned? i nst ance_var i abl e_get
i nst ance_var i abl e_get i nst ance_var i abl e_set
i nst ance_var i abl e_set i nst ance_var i abl es i s_a? ki nd_of ?
met hod met hods new ni l ? obj ect _i d pr i vat e_met hods
pr ot ect ed_met hods publ i c_met hods r emove_i nst ance_var i abl e
r espond_t o? send si ngl et on_met hod_added
si ngl et on_met hod_r emoved si ngl et on_met hod_undef i ned
si ngl et on_met hods t ai nt t ai nt ed? t o_a t o_enum t o_s
t o_yaml t o_yaml _pr oper t i es t o_yaml _st yl e t ype unt ai nt

Control de acceso a miembros en Ruby

Como ya se ha mencionado, tambin en Ruby existen tres palabras
reservadas para el control de acceso a los mtodos de una clase: public, private y
protected. Estas sirven para proteger los mtodos de la clase en diferentes formas.


Tipo de
acceso
Descripcin
private Un mtodo privado bo puede ser llamado mediante un
objeto. Por esta razn, los mtodos privados solo pueden
ser utilizados en la definicin de la clase.
protected Un mtodo protegido puede ser utilizado nicamente
por objetos de la clase donde se define el mtodo, asi
como por sus subclases.
public Un mtodo pblico puede ser utilizado por cualquier
mtodo. Este es visible en cualquier lugar que la clase
sea visible. Los mtodos son pblicos por omisin, con
excepcin del mtodo initialize, el cual es privado.
- 247 -

La diferencia entre privado y protegido es diferente de los lenguajes C++y J ava.
En Ruby, un mtodo protegido puede ser llamado por cualquier instancia de de la
clase donde se define o de sus subclases. Por su parte, un mtodo privado puede
ser llamado solamente en el contexto un objeto de la clase. Los mtodos privados
no puede ser ejecutados directamente ni siquiera por otro objeto de la misma clase
[12]. Ni siquiera el uso de self es vlido para mtodos privados.

Ejemplo:

class Mi Cl ase

def met odo1 # default es 'public'
#...
end

protected # subsecuentes metodos seran 'protected'

def met odo2 # 'protected'
#...
end

private # subsecuentes metodoss seran 'private'

def met odo3 # 'private'
#...
end

public # ssubsecuentes metodoss seran 'public'

def met odo4 # 'public'
#...
end
end

:

class Mi Cl ase

- 248 -
def met odo1
end

. . .

public :metodo1, :metodo4
protected :metodo2
private :metodo3
end

- 249 -

Inicial izadores de superclase

En Ruby, de manera similar a J ava, es posible llamar al mtodo inicializador
de la superclase usando super seguido de la lista de argumentos.

Ejemplo:

class Per sona

attr_accessor :nombre, :edad, :sexo

def i ni t i al i ze( nombr e, edad, sexo)
@nombr e, @edad, @sexo = nombr e, edad, sexo
end

end

class Est udi ant e < Per sona

attr_accessor :matr, :horas

def i ni t i al i ze( nombr e, edad, sexo, mat r , hor as)
super( nombr e, edad, sexo)
@mat r = mat r
@hor as = hor as
end

# ...

end

# Creando dos objetos
a = Per sona. new( " I r onman" , 37, " m" )
b = Est udi ant e. new( " Spi der man" , 36, " m" , " 000- 13- 5031" , 24)

- 250 -
Manej o de objetos de l a subcl ase como obj etos de una superclase en Ruby

El manejo de objetos de subclase como objetos de superclase no es posible en
Ruby, debido a que los identificadores no tienen un tipo de dato

Ejemplo:

# definicion de clase point
class Poi nt
attr_reader :x, :y

protected
@x
@y # coordenadas del punto

# constructor
def i ni t i al i ze a, b
set Poi nt a, b
end

# asigna a x,y las coordenadas del punto
public
def set Poi nt a, b
@x = a
@y = b
end

# convierte informacion a cadena
def t o_s
return " [ #{@x}, #{@y} ] "
end
end

# Definicion de clase circulo
class Ci r cl e < Poi nt # Hereda de Point
attr_reader :radius

@r adi us
- 251 -

# Constructor
def i ni t i al i ze r , a, b
super a, b # llamada a constructor de clase base
set Radi us r
end

# Asigna radio del circulo
def set Radi us r
@r adi us = ( r >= 0 ? r : 0 )
end

# Calculo area del circulo
def ar ea
return 3. 14159 * r adi us * r adi us
end

# Convierte informacion en cadena
def t o_s
return " Cent r o = [ #{@x}, #{@y} ] ; Radi o = #{@r adi us}"
end
end

# cdigo de Prueba de las clases Point y Circle

def pr ueba
p = Poi nt . new 3. 5, 5. 3
c = Ci r cl e. new 2. 7, 1. 2, 8. 9

put s " Punt o p: " + p. t o_s
put s " Ci r cul o c: " + c. t o_s

# Tratamiento del circulo como instancia de punto
poi nt Ref = c; # asignar circulo c a pointRef no hace
diferencia porque los identificadores no tienen tipo
# en realidad Ruby lo reconoce dinmicamente como objeto
Circle sin importar el identificador
put s " Ci r cul o c ( vi a poi nt Ref ) : " + poi nt Ref . t o_s
- 252 -

poi nt Ref = c; # asigna circulo c a pointref. Se repite
la operacion por claridad
ci r cl eRef = poi nt Ref # es asignacin de referencias sin
importar el tipo

end

pr ueba

Redefi ni cin de mtodos

Ruby permite redefinir un mtodo de la clase base en la clase derivada.
Cuando se hace referencia al nombre del mtodo, se ejecuta la versin de la clase
en donde fue redefinida. Es posible sin embargo, utilizar el mtodo de la clase
base por medio la palabra super. A diferencia de J ava aqu solo es necesaria esta
palabra (y si se necesita la lista de argumentos) para llamar al mtodo
correspondiente de la clase base desde la clase derivada.

Ejemplo:

#clase empleado
class Empl eado
@f i r st Name
@l ast Name

def i ni t i al i ze f i r st , l ast
@f i r st Name = St r i ng. new( f i r st )
@l ast Name = St r i ng. new( l ast )
end

def pr i nt
put s @f i r st Name. t o_s + " " + @l ast Name. t o_s
end
end

- 253 -
#clase TrabajadorporHora
class Tr abaj ador Por Hor a < Empl eado
@wage
@hour s

def i ni t i al i ze f i r st , l ast , i ni t Hour s, i ni t Wage
super f i r st , l ast
@hour s = i ni t Hour s
@wage = i ni t Wage
end

def get Pay
@wage * @hour s
end

def pr i nt
put s " Met odo pr i nt de Tr abaj ador por hor a"

super # llama a funcin de clase base

put s " es un t r abaj ador por hor a con suel do de" +" $"
+ get Pay. t o_s
end
end

#prueba de clases
e= Empl eado. new " nombr e" , " apel l i do"

h= Tr abaj ador Por Hor a. new " J uani t o" , " Per ez" , 40. 0, 7. 50
e. pr i nt
h. pr i nt ( ) ;

- 254 -

Mdulos

Un mdulo es definido con la sintaxis:

module <nombr e- mdul o>

<cdi go>

end

De hecho, un mdulo, aunque es similar a una clase no puede tener
imstancias ni subclases y aade un nuevo alcance para variables locales. Un
mdulo que es definido con el nombre de otro previamente definido aadira sus
definiciones al mdulo inicial. En el diseo de Ruby, la clase Module de module
es la superclase de la clase Class de class ! [13]

Cuando existe ambigedad , es posible referirse a un mtodo o identificador
dentro de un mdulo usando el operador ::, por ejemplo:

nombr e- mdul o: : mt odo

Tambin es posible referirse directamente a los elementos dentro de un
mdulo sin necesidad de usar el nombre del mdulo y el operador :: en cada
ocasin. Para esto podemos incluir (include) el mdulo. Esta caracterstica da
adems lugar a los mixins que se vern posteriormente. Es importante notar que
include hace referencia a un mdulo y no a un archivo. Si el mdulo esta en un
diferente archivo, este debe ser solicitado mediante la instruccin require antes de
poder ser incluido [12].

- 255 -
Mixins

En lugar de interfaces, Ruby tiene mixins, que es es la capacidad de un
mdulo de ser aadido a una clase o a otro mdulo con la operacin include [9].
De hecho, un mixin puede verse como una interfaz pero con sus mtodos
implementados. Adems, es posible heredar caractersticas de uno o mas mixins
(mdulos) siendo esto herencia mltiple. El concepto de mixin apareci en el
lenguaje Flavors. El nombre fue inspirado en una mquina de helados que ofrecia
en sabores bsicos mezclados con ingredientes extras, estos helados eran
llamados Mix-In.
35

Es importante sealar que en la definicin del mdulo pueden incluirse
atributos y restricciones de acceso, mismos que sern pasados a la clase que
incluye dicho mdulo. Una vez definido el mdulo, ste puede ser aadido a una
clase de la siguiente forma:

class unaCl ase
include <nombr e- mdul o>
. . .
end

Ejemplo:

#modulo
module St ack
def push( i t em) end
def pop; end
end

#clase incluye modulo
class St ackI mpl
include St ack

35
For a real ice cream treat, try _Steve's Ice Cream_ (191 Elm Street, Sommerville). Steve's homemade ice
cream is perhaps the best in town. Cones are $.35 and $.55, and for $.10 each you can choose "mix-ins,"
consisting of M&M's, Heath bars, and many others. If you want fruit mixed in it costs $.10 more. Sundaes
are $.75 and $1.25, banana splits are $1.75, and egg creams are $.40. The portions at Steve's are large, and
so are the lines, so expect to do a little waiting. It's worth it. [14] pg. 224
- 256 -
@st ackAr r ay
@t os
public
@st ackAr r ay = [ ]
@t os = - 1
end

#implementa el mtodo definido en el mdulo
def push i t em

@st ackAr r ay[ @t os+=1] = i t em
end

#implementa el mtodo definido en el mdulo
def pop
obj Ref = @st ackAr r ay[ @t os]
@st ackAr r ay[ @t os] = nil
@t os- =1
return obj Ref
end

def peek
return @st ackAr r ay[ @t os]
end
end

# extendiendo un mdulo puede ser hecho en el mismo mdulo
# dinmicamente o en otro mdulo. Pero en este caso las
queremos separadas
=begin
module Stack
def isEmpty
end
def isFull
end
end
=end
module Saf eSt ack
def i sEmpt y
- 257 -
end
def i sFul l
end
end

# esta clase hereda la implementacin de la pila StackImpl
# e implementa la nueva interfaz extendida SafeStack
class Saf eSt ackI mpl < St ackI mpl
include Saf eSt ack

super
end

# implementa los mtodos de la interfaz
def i sEmpt y
return t os < 0
end
def i sFul l
t os >= st ackAr r ay. l engt h
end
end

def st ackUser
saf eSt ackRef = Saf eSt ackI mpl . new

saf eSt ackRef . push( " Dol ar " ) ;
saf eSt ackRef . push " Peso"
put s saf eSt ackRef . pop
put s saf eSt ackRef . pop

put s saf eSt ackRef . class
end

st ackUser

Aunque la instruccin include nos puede recordar a la misma instruccin en
C/C++, en realidad es diferente. #imclude en C/C++es ejecutada por el
preprocesador e indica que el archivo correspondiente debe ser insertado
momentos previos a la compilacin.
- 258 -

Adems, en Ruby, no se copia el cdigo, sino que se hace una referencia de
la clase al mdulo incluido. Mltiples clases pueden tener referencia al mismo
mdulo y si este mdulo es modificado, inclusive mientras el programa esta
ejecutndose, todas las clases se vern afectadas en su comportamiento [12].
Mucha de la fuerza del uso de mixins esta en la funcionalidad que aade a las
clases, pero en cdigo bien diseado este poder puede verse an ms si el cdigo
en el mixin interactua con el cdigo de las clases.
- 259 -

Asociaciones entre clases en C++

Una clase puede estar relacionada con otra clase, o en la prctica un objeto
con otro objeto.

En el modelado de objetos a la relacin entre clases se le conoce como
asociacin; mientras que a la relacin entre objetos se le conoce como instancia
de una asociacin.

Ejemplo:

Una clase Estudiante est relacionada con una clase Universidad.

Una relacin es una conexin fsica o conceptual entre objetos. Las
relaciones
36
se consideran de naturaleza bidireccional; es decir, ambos lados de la
asociacin tienen acceso a clase del otro lado de la asociacin. Sin embargo,
algunas veces nicamente es necesaria una relacin en una direccin
(unidireccional).

Profesor Cubculo
Asociacin

Comnmente las asociaciones se representan en los lenguajes de
programacin orientados a objetos como apuntadores. Donde un apuntador a una
clase B en una clase A indicara la asociacin que tiene A con B; aunque no as la
asociacin de B con A.

36
El trmino de relacin es usado muchas veces como sinnimo de asociacin, debido a que el concepto
surge de las relaciones en bases de datos relacionales. Sin embargo el trmino ms apropiado es el de
asociacin, ya que existen en objetos otros tipos de relaciones, como la relacin de agregacin y la de
herencia.
- 260 -

Para una asociacin bidireccional es necesario al menos un par de
apuntadores, uno en cada clase. Para una asociacin unidireccional basta un solo
apuntador en la clase que mantiene la referencia.
Ejemplo: un programa que guarda una relacin bidireccional entre clases A y B.

class A{
/ / l i st a de at r i but os

B *pB;
};

class B{
A *pA;
};

En el ejemplo anterior se presenta una relacin bidireccional, por lo que
cada clase tiene su respectivo apuntador a la clase contraria de la relacin.
Adems, deben proporcionarse mtodos de acceso a la clase relacionada por
medio del apuntador.

En el caso de las relaciones se asumir que cada objeto puede seguir
existiendo de manera independiente, a menos que haya sido creado por el objeto
de la clase relacionada, en cuyo caso deber ser eliminado por el destructor del
objeto que la cre. Es decir:

Si el obj et o A cr ea al obj et o B, es r esponsabi l i dad de A
el i mi nar a l a i nst anci a B ant es de que A sea el i mi nada. En
caso cont r ar i o, si B es i ndependi ent e de l a i nst anci a A, A
deber a envi ar un mensaj e al obj et o B par a que asi gne NULL al
apunt ador de B o par a que t ome una medi da per t i nent e, de
maner a que no quede apunt ando a una di r ecci n i nvl i da.

Es importante sealar que las medidas que se tomen pueden variar de
acuerdo a las necesidades de la aplicacin, pero bajo ningn motivo se deben
- 261 -
dejar accesos a reas de memoria no permitidas o dejar objetos "volando", sin que
nadie haga referencia a ellos.

Mencionamos a continuacin estructuras clsicas que pueden ser vistas como
una relacin:

1. Ejemplo de relacin unidireccional: lista ligada.

2. Ejemplo de relacin bidireccional: lista doblemente ligada.

Asociaci ones reflexi vas en C++

Es posible tener un tipo de asociacin conocida como asociacin reflexiva.

Si una clase mantiene una asociacin consigo misma se dice que es una
asociacin reflexiva.

Ejemplo: Persona puede tener relaciones entre si, si lo que nos interesa es
representar a las personas que guardan una relacin entre s, por ejemplo si son
parientes. Es decir, un objeto mantiene una relacin con otro objeto de la misma
clase.

Persona
Asociacin reflexiva

En terminos de implementacin significa que la clase tiene una referencia a
si misma. De nuevo podemos poner de ejemplo a la clase Nodo en una lista
ligada.
- 262 -
Mul ti pli cidad de una asociaci n en C++

La multiplicidad de una asociacin especifica cuantas instancias de una
clase se pueden relacionar a una sola instancia de otra clase.

Se debe determinar la multiplicidad para cada clase en una asociacin.

Tipos de asociaciones segn su multiplicidad

"uno a uno": donde dos objetos se relacionan de forma exclusiva, uno con el
otro.

Ejemplo:
Uno: Un alumno tiene una boleta de calificaciones.
Uno: Una boleta de calificaciones pertenece a un alumno.

"uno a muchos": donde uno de los objetos puede estar relacionado con
muchos otros objetos.

Ejemplo:
Uno: un libro solo puede estar prestado a un alumno.
Muchos: Un usuario de la biblioteca puede tener muchos libros
prestados.

"muchos a muchos": donde cada objeto de cada clase puede estar relacionado
con muchos otros objetos.

Ejemplo:
Muchos: Un libro puede tener varios autores.
Muchos: Un autor puede tener varios libros.

- 263 -
Podemos apreciar en un diagrama las diversas multiplicidades:

1 1
*
* *
Empleo
*
Proyecto
Departamento

La forma de implementar en C++este tipo de relaciones puede variar, pero
la ms comn es por medio de apuntadores a objetos. Suponiendo que tenemos
relaciones bidireccionales:

"uno a uno". Un apuntador de cada lado de la relacin, como se ha visto
anteriormente.

"uno a muchos". Un apuntador de un lado y un arreglo de apuntadores a
objetos definido dinmica o estticamente.

class A{
. . .
B *pB;
};

class B{
A *p[5];
/ /
A **p;
}

Otra forma es manejar una clase que agrupe a pares de direcciones en un
objeto independiente de la clase. Por ejemplo una lista o tabla de referencias.

- 264 -

Persona

Persona
Compaa

Compaa

Persona

Persona

"muchos a muchos". Normalmente se utiliza un objeto u objetos
independientes que mantiene las relaciones entre los objetos, de manera similar
a la grfica anterior.

Ejemplo:
Se muestra un cdigo simplificado para manejo de asociaciones.

Clase Libro

#ifndef LI BRO_H_
#define LI BRO_H_

class Per sona;

class Li br o {
public:
char nombr e[ 10] ;
Per sona *pPer sona;

Li br o( ) ;
~Li br o( ) ;
};

#endif / *LI BRO_H_*/

#include " Per sona. h"
#include " Li br o. h"

- 265 -
Li br o: : Li br o( ) {
nombr e[ 0] =' \ 0' ;
pPer sona=NULL;
}

Li br o: : ~Li br o( ) {
if( pPer sona! =NULL)
for( int i =0; i <5; i ++)
if ( pPer sona- >pLi br osPr es[ i ] ==this)
pPer sona- >pLi br osPr es[ i ] =NULL;

}

Clase Persona

#ifndef PERSONA_H_
#define PERSONA_H_

class Li br o;

class Per sona {
public:
Li br o *pLi br osPr es[ 5] ;

Per sona( ) ;
~Per sona( ) ;
};

#endif / *PERSONA_H_*/

#include " Li br o. h"
#include " Per sona. h"

Per sona: : Per sona( ) {
int i ;

for( i =0; i <5; i ++)
pLi br osPr es[ i ] =NULL;
}
- 266 -

Per sona: : ~Per sona( ) {
int i ;
for( i =0; i <5; i ++)
if( pLi br osPr es[ i ] ! =NULL)
pLi br osPr es[ i ] - >pPer sona=NULL;
}

Asociaciones entre Clases en Java

Como en J ava el manejo de objetos es mediante referencias, la
implementacin de la asociacin se simplifica en la medida que la sintaxis de
J ava es ms simple.

Ejemplo: un cdigo que guarda una asociacin bidireccional entre clases A y B.

class A{

B pB;
}

class B{
A pA;
}

En el ejemplo anterior se presenta una relacin bidireccional, por lo que
cada clase tiene su respectiva referencia a la clase contraria de la relacin.
Adems, deben proporcionarse mtodos de acceso a la clase relacionada por
medio de la referencia.

Una asociacin unidireccional del ejemplo anterior sera ms simple.
Veamos el cdigo si se requiere nicamente una relacin de A a B.

- 267 -
Ejemplo:

class A{
B pB;
}

class B{
}

Recordar: Si el obj et o A cr ea al obj et o B, es
r esponsabi l i dad de A el i mi nar a l a i nst anci a B ant es de que A
sea el i mi nada. En caso cont r ar i o, si B es i ndependi ent e de l a
i nst anci a A, A deber a envi ar un mensaj e al obj et o B par a que
asi gne null al apunt ador de B o par a que t ome una medi da
per t i nent e, de maner a que no quede apunt ando a una di r ecci n
i nvl i da.

En J ava, ya que cuenta con un recolector de basura, la importancia radicara
en asegurarnos de no mantener enlaces a objetos que ya no son necesarios.

Asociaci n refl exi va en Java

La asociacin reflexiva es un concepto que no tiene diferencias con respecto
a C++.

Mul ti pli cidad de una asociaci n en Java

La forma de implementar en J ava este tipo de relaciones puede variar, pero
la ms comn es por medio de referencias a objetos. Suponiendo que tenemos
relaciones bidireccionales:

"uno a uno". Una referencia de cada lado de la relacin, como se ha visto
anteriormente.
- 268 -

"uno a muchos". Una referencia de un lado y un arreglo de referencias a
objetos del otro lado.

class A{
. . .
B pB;
}
class B{
A p[];
}

Al igual que en C++, es posible manejar una clase independiente que agrupe
a pares de direcciones en un objeto independiente de la clase
37
. Por ejemplo, en
una estructura de lista.

"muchos a muchos". Normalmente se utiliza un objeto u objetos
independientes que mantiene las relaciones entre los objetos, de manera similar
a la solucin descrita en el punto anterior.

Ejemplo:
Se muestra un cdigo simplificado para manejo de asociaciones.

/ / cl ase Li br o
class Li br o {
private St r i ng nombr eLi br o;
public Al umno pAl umno;

public Li br o( ) {
/ / al moment o de cr ear se l a i nst anci a, no exi st e
/ / r el aci n con ni ngn Al umno
pAl umno=null;
}


37
Ver figura en tema correspondiente de C++
- 269 -
/ / si es di f er ent e de nul l , el l i br o est asi gnado a
al gn Al umno
if( pAl umno! =null)
/ / busca l a r ef er enci a de Al umno a Li br o par a
poner l a en nul l
for( int i =0; i <5; i ++)
if ( pAl umno. pLi br osPr es[ i ] ==this)
pAl umno. pLi br osPr es[ i ] =null;
}
}

/ / cl ase Al umno
class Al umno {
public Li br o pLi br osPr es[ ] ;
public Al umno( ) {
int i ;
/ / se asume una mul t i pl i ci dad de 5
pLi br osPr es = new Li br o[ 5]
for( i =0; i <5; i ++)
pLi br osPr es[ i ] =null;
}


/ / pone en nul l t odas l as asoci aci ones de l os Li br os
/ / a su i nst anci a de Al umno que se el i mi na
for( int i =0; i <5; i ++)
if( pLi br osPr es[ i ] ! =null)
pLi br osPr es[ i ] . pAl umno=null;
}
}

Este es un ejemplo incompleto de cmo se soluciona el manejo de
asociaciones entre clases, ya que adems se deben de agregar mtodos para
establecer y eliminar la asociacin, en ambas clases si es una asociacin
bidireccional, o en una clase nicamente si se trata de una asociacin
unidireccional. Esos deben de ser los nicos mtodos que tengan el control sobre
los atributos que mantienen la asociacin y no deberan ser manejados
directamente, por lo que no deben ser pblicos como aqu se presentaron.
- 270 -

Finalmente, es evidente que el control de las asociaciones no se encuentra
actualmente apoyado por los lenguajes de programacin, a pesar de ser una
necesidad natural en el modelado orientado a objetos, por lo que toda la
responsabilidad recae sobre el programador.

Una definicin ms completa - sin cdigo - de la clase Libro se aprecia a
continuacin:

class Li br o {
private St r i ng nombr eLi br o;
private St r i ng cl ave;
public Al umno pAl umno;

public Li br o( ) { }

public Li br o( Al umno pAl umno) { }

public St r i ng get Nombr eLi br o( ) { }

public void set Nombr eLi br o( St r i ng n) { }

public St r i ng get Cl ave( ) { }

public void set Cl ave( St r i ng cve) { }

public boolean set Asoci aci on( Al umno pAl umno) { }

public boolean unset Asoci aci on( ) { }

public Al umno get Al umno( ) { }

protected f i nal i ze {}
}

Este sera un estilo ms apropiado para el desarrollo de asociaciones, aunque
existen otros ms elaborados.
- 271 -
Asociaciones entre Clases en Ruby

El manejo de asociaciones en Ruby puede hacerse de forma similar a como
se mencion en J ava. De hecho es todava ms simple la definicin debido a que
no es necesaria la declaracin de tipos.

Ejemplo: un cdigo que guarda una asociacin bidireccional entre clases A y B.

class A
#lista de atributos
@pB
end

class B
#lista de atributos
@pA
end

Veamos el cdigo si se requiere nicamente una relacin de A a B.

Ejemplo:

class A
#lista de atributos
@pB
end

class B
#lista de atributos
end
Asociaci n refl exi va en Ruby

La asociacin reflexiva es un concepto que no tiene diferencias con respecto
a C++y J ava.

- 272 -
Mul ti pli cidad de una asociaci n en Ruby

La forma de implementar en Ruby este tipo de relaciones puede variar, pero
la ms comn es por medio de referencias a objetos, de forma similar a la usada
en J ava.

- 273 -
Objetos compuestos en C++

Algunas veces una clase no puede modelar adecuadamente una entidad
basndose nicamente en tipos de datos simples. Los LPOO permiten a una clase
contener objetos. Un objeto forma parte directamente de la clase en la que se
encuentra declarado.

El objeto compuesto es una especie de relacin, pero con una asociacin
ms fuerte con los objetos relacionados. A la nocin de objeto compuesto se le
conoce tambin como objeto complejo o agregado.

Rumbaugh define a la agregacin como "una forma fuerte de asociacin,
en la cual el objeto agregado est formado por componentes. Los componentes
forman parte del agregado. El agregado, es un objeto extendido que se trata como
una unidad en muchas operaciones, aun cuando conste fsicamente de varios
objetos menores." [15]

Ejemplo: Un automvil se puede considerar ensamblado o agregado, donde
el motor y la carrocera serian sus componentes.

El concepto de agregacin puede ser relativo a la conceptualizacin que se
tenga de los objetos que se quieran modelar.

Dicho concepto implica obviamente cierta dependencia entre los objetos, por
lo que hay que tener en cuenta que pasa con los objetos que son parte del objeto
compuesto cuando ste ltimo se destruye. En general tenemos dos opciones:

1. Cuando el objeto agregado se destruye, los objetos que lo componen no tienen
necesariamente que ser destruidos.

2. Cuando el agregado es destruido tambin sus componentes se destruyen.

- 274 -
Por el momento vamos a considerar la segunda opcin, por ser ms fcil de
implementar y porque es la accin natural de los objetos que se encuentran
embebidos como un atributo ms en una clase.

Ejemplo:

class Nombr e {
private:
char pat er no[ 20] ,
mat er no[ 20] ,
nom[ 15] ;
public:
set ( char *, char*, char *) ;
. . .
};

class Per sona {
private:
int edad;
Nombr e nombr ePer sona;
. . .
};

Al crear un objeto compuesto, cada uno de sus componentes es creado con
sus respectivos constructores. Para inicializar esos objetos componentes tenemos
dos opciones:

1. En el constructor del objeto compuesto llamar a los mtodos set
correspondientes a la modificacin de los atributos de los objetos
componentes.

2. Pasar en el constructor del objeto compuesto los argumentos a los
constructores de los objetos componentes.

- 275 -

Sintaxis:

<cl ase>: : <const r uct or >( <l i st a de ar gument os>) : <obj et o
component e 1>( <l i st a de ar gument os si n el t i po>) , . . .

donde la lista de argumentos del objeto compuesto debe incluir a los argumentos
de los objetos componentes, para que puedan ser pasados en la creacin del
objeto.

Ejemplo:



class Nombr e {
char *nombr e,
*pat er no,
*mat er no;
public:
Nombr e( char *n, char *p, char*m) {
nombr e=new char[ st r l en( n) +1] ;
pat er no=new char[ st r l en( p) +1] ;
mat er no=new char[ st r l en( m) +1] ;
st r cpy( nombr e, n) ;
st r cpy( pat er no, p) ;
st r cpy( mat er no, m) ;
}
~Nombr e( ) {
cout <<" dest r uct or de Nombr e: " <<nombr e<<endl ;
delete [ ] nombr e;
delete [ ] pat er no;
delete [ ] mat er no;
}
};

- 276 -
class Per sona{
Nombr e mi Nombr e;
int edad;
public:
Per sona( char *n, char *p, char*m) : mi Nombr e( n, p, m) {
edad=0;
}
};

int mai n( ) {
Per sona *per 1;
per 1= new Per sona( " uno" , " dos" , " t r es" ) ;
Per sona per 2( " Bob" , " t he" , " bui l der " ) ;
delete per 1;
return 0;
}

Un objeto que es parte de otro objeto, puede a su vez ser un objeto
compuesto. De esta forma podemos tener mltiples niveles. Un objeto puede ser
un agregado recursivo, es decir, tener un objeto de su misma clase.

Ejemplo: Directorio de archivos.

Sin embargo, la forma en que estamos implementando la agregacin no
permite la agregacin recursiva.

- 277 -
UMLGEC ++

El proyecto de desarrollo de esta herramienta CASE (UMLGEC ++)[16, 17]
soporta la notacin UML
38
para diagramas de clase y generacin de cdigo en
C++, con una interfaz lo mas completa y sencilla posible. Siendo til para
entender grficamente conceptos bsicos de objetos y su correspondiente
implementacin en cdigo. Los elementos de este software son:
Depsito de datos
Mdulo para Creacin de Diagramas y Modelado
Generador de cdigo
Analizador de sintaxis

38
Informacin bsica sobre UML puede ser vista en [18].
- 278 -

De la generacin de cdigo se puede decir:

A partir del diagrama se genera la estructura de las clases.
Se crean automticamente: el constructor, el constructor de copia, el operador
de asignacin, las operaciones de igualdad y el destructor.
Todos los atributos y asociaciones son establecidos como privados
independientemente de la visibilidad establecida por el usuario, pero el acceso
a ellos est permitido mediante operaciones get y set generadas
automticamente para cada atributo o asociacin, las cules adquieren la
visibilidad correspondiente al atributo o asociacin al que hacen referencia.
Se definen los cuerpos de las operaciones get y set, como funciones inline.

- 279 -
Objetos compuestos en Java

En J ava, puede no existir mucha diferencia entre la implementacin de la
asociacin y la agregacin, debido a que en J ava los objetos siempre son
manejados por referencias, pero el concepto se debe tener en cuenta para su
manejo, adems de ser relevante a nivel de diseo de software.

Recordemos que en general hay dos opciones para el manejo de la
agregacin:

1. Cuando el objeto agregado se destruye, los objetos que lo componen no
tienen necesariamente que ser destruidos.


Al igual que en C++, vamos a considerar la segunda opcin, por ser ms
fcil de implementar y es la accin natural de los objetos que se encuentran
embebidos como un atributo ms una clase.

Ejemplo:

class Nombr e {
private St r i ng pat er no;
private St r i ng mat er no;
private St r i ng nom;

public set ( St r i ng pat , St r i ng mat , St r i ng n) {
. . .
}
. . .
}

class Per sona {
private int edad;
private Nombre nombr ePer sona;
. . .
- 280 -
}

A diferencia de lo que sucede en C++, los atributos compuestos no tienen
memoria asignada, es decir, los objetos compuestos no han sido realmente
creados en el momento en que se crea el objeto componente. Es responsabilidad
del constructor del objeto componente inicializar los objetos miembros o
compuestos, si es que as se requiere.

Para inicializar esos objetos componentes tenemos dos opciones:

1. En el constructor del objeto compuesto llamar a los mtodos set
correspondientes a la modificacin de los atributos de los objetos
componentes, esto despus claro est de asignarle la memoria a los objetos
componentes.

2. Llamar a algn constructor especializado del objeto componente en el
momento de crearlo.

Ejemplo:

/ / Pr ogr ama Per sona
class Nombr e {
private St r i ng nombr e,
pat er no,
mat er no;
public Nombr e( St r i ng n, St r i ng p, St r i ng m) {
nombr e= new St r i ng( n) ;
pat er no= new St r i ng( p) ;
mat er no= new St r i ng( m) ;
}
}

public class Per sona{
private Nombre mi Nombr e;
private int edad;
public Per sona( St r i ng n, St r i ng p, St r i ng m) {
mi Nombr e= new Nombr e( n, p, m) ;
- 281 -
edad=0;
}

Per sona per 1;
per 1= new Per sona( " uno" , " dos" , " t r es" ) ;
Per sona per 2= new Per sona( " mi nombr e" , " mi apel l i do" ,
" ot r o apel l i do" ) ;
}
}

La agregacin nos dice tambin que un objeto que es parte de otro objeto,
puede a su vez ser un objeto compuesto. [19]

De esta forma podemos tener mltiples niveles. De hecho esto se ve en el
cdigo anterior, si consideramos que en realidad String es una clase y no un tipo
de dato simple. As, se van ensamblando clases para formar una clase ms grande
con una mayor funcionalidad, del mismo modo que el ensamble de objetos del
mundo real.

Pero tambin es posible que un objeto sea un agregado recursivo, es decir,
tener como parte de su componente un objeto de su misma clase. Considerar por
ejemplo un directorio de archivos, donde cada directorio puede contener, adems
de archivos, a otros directorios
39
.

Otro ejemplo en J ava:

/ / Cl ase MyDat e
public class MyDat e {
private int mont h; / / 1- 12
private int day; / / 1- 31 dependi endo del mes

39
Lo importante aqu es considerar en que solo existe la posibilidad de contener un objeto de si mismo. Si
esto fuera una condicin obligatoria y no opcional, estaramos definiendo un objeto infinito. Este problema
se ve reflejado en lenguajes como C++, donde la forma ms simple de implementar la agregacin es
definiendo un objeto al cual se le asigna espacio en tiempo de compilacin, generando entonces el problema
de que cada objeto debe reservar memoria para sus componentes, por lo que el compilador no permite que de
esta manera se autocontenga. En Java esto no generara problema porque implcitamente todos los atributos
que no son datos simples requieren de una asignacin de memoria dinmica.
- 282 -
private int year ; / / cual qui er ao

public MyDat e( int mn, int dy, int yr ) {
if ( mn > 0 && mn <= 12 )
mont h = mn;
else {
mont h = 1;
Syst em. out. pr i nt l n( " Mes " + mn +
" i nval i do. Se asi gno el mes 1. " ) ;
}

year = yr ;
day = checkDay( dy ) ; / / val i dar el di a

Syst em. out. pr i nt l n( " Const r uct or de obj et o MyDat e par a
f echa " + t oSt r i ng( ) ) ;
}

/ / ver i f i ca que el di a sea cor r ect o de acuer do al mes
private int checkDay( int t est Day ) {
int daysPer Mont h[ ] = { 0, 31, 28, 31, 30,
31, 30, 31, 31, 30,
31, 30, 31 };

if ( t est Day > 0 && t est Day <= daysPer Mont h[ mont h ] )
return t est Day;

if ( mont h == 2 && / / Febr er o, si el ao es bi si est o
t est Day == 29 &&
( year %400 == 0 | |
( year %4 == 0 && year %100 ! = 0 ) ) )
return t est Day;

Syst em. out. pr i nt l n( " Di a " + t est Day +
" i nval i do. Se asi gno el di a 1. " ) ;

return 1; / / dej a al obj et o en un est ado consi st ent e
}

public St r i ng t oSt r i ng( )
- 283 -
{ return mont h + " / " + day + " / " + year ; }
}

/ / Cl ase Empl eado
public class Empl oyee {

private St r i ng f i r st Name;
private St r i ng l ast Name;
private MyDat e bi r t hDat e;
private MyDat e hi r eDat e;

public Empl oyee( St r i ng f Name, St r i ng l Name,
int bMont h, int bDay, int bYear ,
int hMont h, int hDay, int hYear ) {
f i r st Name = f Name;
l ast Name = l Name;
bi r t hDat e = new MyDat e( bMont h, bDay, bYear ) ;
hi r eDat e = new MyDat e( hMont h, hDay, hYear ) ;
}

return l ast Name + " , " + f i r st Name +
" Cont r at ado: " + hi r eDat e. t oSt r i ng( ) +
" Fecha naci mi ent o: " + bi r t hDat e. t oSt r i ng( ) ;
}
}
/ / cl ase Empl oyeeTest
public class Empl oyeeTest {

private Empl oyee e;

public Empl oyeeTest ( ) {
e = new Empl oyee( " J uani t o" , " Sanchez" , 7, 24, 49,
3, 12, 88 ) ;
}

Empl oyeeTest et = new Empl oyeeTest ( ) ;
Syst em. out. pr i nt l n( et . e. t oSt r i ng( ) ) ; }
}
- 284 -
Objetos compuestos en Ruby

En Ruby, como en J ava, puede no existir mucha diferencia entre la
implementacin de la asociacin y la agregacin, debido a que en Ruby los
objetos siempre son manejados por referencias, pero el concepto se debe tener en
cuenta para su manejo, adems de ser relevante a nivel de diseo de software.

Recordemos que en general hay dos opciones para el manejo de la
agregacin:

1. Cuando el objeto agregado se destruye, los objetos que lo componen no
tienen necesariamente que ser destruidos.


Al igual que en C++y J ava, vamos a considerar la segunda opcin, por ser
ms fcil de implementar y es la accin natural de los objetos que se encuentran
embebidos como un atributo ms una clase.

Ejemplo:

class Nombr e
@pat er no
@mat er no
@nom

def set ( pat er no, mat er no, nombr e)
. . .
end
. . .
end

class Per sona
@edad
@nombrePersona
. . .
- 285 -
end

Como ya se sabe, los identificadores para los atributos no tienen un tipo
asociado, sino que son asignados a un objeto en tiempo de ejecucin. Es
responsabilidad del inicializador del objeto componente inicializar los objetos
miembros o compuestos, si es que as se requiere.

Ejemplo:

#Programa Persona
class Nombr e
@nombr e
@pat er no
@mat er no
def i ni t i al i ze( nombr e, pat er no, mat er no)
@nombr e= St r i ng. new nombr e
@pat er no= St r i ng. new pat er no
@mat er no= St r i ng. new mat er no
end
end

class Per sona
@miNombre
@edad
def i ni t i al i ze( n, p, m)
@mi Nombr e = Nombr e. new( n, p, m)
@edad =0
end
end

#cdigo de prueba
per 1= Per sona. new( " uno" , " dos" , " t r es" )
per 2= Per sona. new( " mi nombr e" , " mi apel l i do" , " ot r o apel l i do" )

Otro ejemplo en Ruby:

# Clase MyDate
class MyDat e
- 286 -
@mont h # 1-12
@day # 1-31 dependiendo del mes
@yea; # cualquier ao

def i ni t i al i ze ( mn, dy, yr )
if ( mn > 0 && mn <= 12 )
@mont h = mn;
else
@mont h = 1;
put s " Mes #{mn} i nval i do. Se asi gno el mes 1. "
end

@year = yr ;
@day = checkDay( dy ) ; # validar el dia

put s " I ni ci al i zador de obj et o MyDat e par a f echa " + t o_s
end

# verifica que el dia sea correcto de acuerdo al mes
def checkDay ( t est Day)
daysPer Mont h = [ 0, 31, 28, 31, 30,
31, 30, 31, 31, 30,
31, 30, 31]

if ( t est Day > 0 && t est Day <= daysPer Mont h[ @mont h] )
return t est Day
end

if ( @mont h == 2 && # Febrero, si el ao es bisiesto
t est Day == 29 &&
( @year %400 == 0 | |
( @year %4 == 0 && @year %100 ! = 0 ) ) )
return t est Day
end

put s " Di a #{t est Day. t o_s} i nval i do. Se asi gno el di a 1. "

return 1 # deja al objeto en un estado consistente
end

- 287 -
def t o_s
return @mont h. t o_s + " / " + @day. t o_s + " / " + @year . t o_s
end
end

# Clase Empleado
class Empl oyee

@f i r st Name
@l ast Name
@bi r t hDat e
@hi r eDat e

def i ni t i al i ze ( f Name, l Name, bMont h, bDay, bYear ,
hMont h, hDay, hYear )
@f i r st Name = f Name
@l ast Name = l Name
@bi r t hDat e = MyDat e. new( bMont h, bDay, bYear )
@hi r eDat e = MyDat e. new( hMont h, hDay, hYear )
end

def t o_s
return @l ast Name + " , " + @f i r st Name +
" Cont r at ado: " + @hi r eDat e. t o_s +
" Fecha naci mi ent o: " + @bi r t hDat e. t o_s
end
end

# clase EmployeeTest
class Empl oyeeTest
attr_reader :e
@e

@e = Empl oyee. new( " J uani t o" , " Sanchez" , 7, 24, 49,
3, 12, 88 )
end

end

- 288 -
# codigo de prueba
et = Empl oyeeTest . new
put s et . e. t o_s

- 289 -
Funciones virtuales y polimorfismo en C++

La capacidad de polimorfismo permite crear programas con mayores
posibilidad de expansiones futuras, an para procesar en cierta forma objetos de
clases que no han sido creadas o estn en desarrollo.[20]

El polimorfismo es implementado en C++a travs de clases derivadas y
funciones virtuales.

Una funcin virtual es un mtodo miembro declarado como virtual en una
clase base y siendo este mtodo redefinido en una o ms clases derivadas.

Las funciones virtuales son muy especiales, debido a que cuando una
funcin es accesada por un apuntador a una clase base, y ste mantiene una
referencia a un objeto de una clase derivada, el programa determina en tiempo de
ejecucin a que funcin llamar, de acuerdo al tipo de objeto al que se apunta.
Esto se conoce como ligadura tarda
40
y el compilador de C++incluye en el
cdigo mquina el manejo de ese tipo de asociacin de mtodos.

La utilidad se da cuando se tiene un mtodo en una clase base, y este es
declarado virtual. De esta forma, cada clase derivada puede tener su propia
implementacin del mtodo si es que as lo requiere la clase; y si un apuntador a
clase base hace referencia a cualquiera de los objetos de clases derivadas, se
determina dinmicamente cual de todos los mtodos debe ejecutar.

La sintaxis en C++implica declarar al mtodo de la clase base con la
palabra reservada virtual, redefiniendo ese mtodo en cada una de las clases
derivadas.

Al declarar un mtodo como virtual, este mtodo se conserva asi a travs de
toda la jerarqua de herencia, del punto en que se declaro hacia abajo. Aunque de

40
Trmino opuesto a ligadura temprana o ligadura esttica, la cual asocia los mtodos en tiempo de
compilacin.
- 290 -
este modo no es necesario volver a usar la palabra virtual en ninguno de los
mtodos inferiores del mismo nombre, es posible declararlo de forma explcita
para que el programa sea ms claro.

Es importante sealar que las funciones virtuales que sean redefinidas en
clases derivadas, deben tener adems de la misma firma que la funcin virtual
base, el mismo tipo de retorno.

Sintaxis:

class base {
virtual <t i po> <mt odo> ( <par met r os) ;
};

Ejemplo:

/ / ej empl o f unci ones vi r t ual es

class base {
public:
virtual void qui en( ) {
cout <<" base\ n" ;
}
};

class pr i mer a: public base {
public:
void qui en( ) {
cout <<" pr i mer a\ n" ;
}
};

class segunda: public base {
public:
void qui en( ) {
- 291 -
cout <<" segunda\ n" ;
}
};

class t er cer a: public base {
};

class cuar t a: public base {
public:
/ / No se val e con un t i po de dat o di f er ent e
/ *i nt qui en( ) {
cout <<" cuar t a\ n" ;
r et ur n 1;
}*/
};

int mai n( ) {
base obj Base, *pBase;
pr i mer a obj 1;
segunda obj 2;
t er cer a obj 3;
cuar t a obj 4;

pBase=&obj Base;
pBase- >qui en( ) ;

pBase=&obj 1;
pBase- >qui en( ) ;

pBase=&obj 2;
pBase- >qui en( ) ;

pBase=&obj 3;
pBase- >qui en( ) ;

pBase=&obj 4;
pBase- >qui en( ) ;

return 0;
}
- 292 -

Hay que hacer notar que las funciones virtuales pueden seguirse usando sin
apuntadores, mediante un objeto de la clase. De esta forma, el mtodo a ejecutar
se determina de manera esttica; es decir, en tiempo de compilacin (ligadura
esttica). Obviamente el mtodo a ejecutar es aquel definido en la clase del objeto
o el heredado de su clase base, si la clase derivada no lo redefini.

Si se declara en una clase derivada un mtodo con otro tipo de dato como
retorno, el compilador manda un error, ya que esto no es permitido.

Si se declara un mtodo con el mismo nombre pero diferentes parmetros, la
funcin virtual queda desactivada de ese punto hacia abajo en la jerarqua de
herencia.

Clase abstracta y clase concreta en C++

Existen clases que son tiles para representar una estructura en particular,
pero que no van a tener la necesidad de generar objetos directamente a partir de
esa clase, estas se conocen como clases abtractas, o de manera ms apropiada
como clases base abstractas, puesto que sirven para definir una estructura
jerarquica.

La clase base abstracta entonces, tiene como objetivo proporcionar una clase
base que ayude al modelado de la jerarqua de herencia, aunque esta sea muy
general y no sea prctico tener instancias de esa clase.

Por lo tanto, de una clase abstracta no se pueden tener objetos, mientras que
en clases a partir de las cuales se puedan instanciar objetos se conocen como
clases concretas.

En C++, una clase se hace abstracta al declarar al menos uno de los
mtodos virtuales como puro. Un mtodo o funcin virtual pura es aquel que en
su declaracin tiene el inicializador de =0 .

- 293 -

virtual <t i po> <nombr e>( <par met r os>) =0; / / vi r t ual pur a

Es importante tener en cuenta que una clase sigue siendo abstracta hasta que
no se implemente la funcin virtual pura, en una de las clases derivadas. Si no se
hace la implementacin, la funcin se hereda como virtual pura y por lo tanto la
clase sigue siendo considerada como abstracta.

Aunque no se pueden tener objetos de clases abstractas, si se pueden tener
apuntadores a objetos de esas clases, permitiendo una manipulacin de objetos de
las clases derivadas mediante los apuntadores a la clase abstracta.

Polimorfismo

El polimorfismo se define como la capacidad de objetos de clases diferentes,
relacionados mediante herencia, a responder de forma distinta a una misma
llamada de un mtodo. [11]

En C++, el polimorfismo se implementa con las funciones virtuales. Al
hacer una solicitud de un mtodo, a travs de un apuntador a clase base para usar
un mtodo virtual, C++determina el mtodo que corresponda al objeto de la clase
a la que pertenece, y no el mtodo de la clase base.

Tener en cuenta que no es lo mismo que simplemente redefinir un mtodo
de clase base en una clase derivada, pues como se vio anteriormente, si se tiene a
un apuntador de clase base y a travs de el se hace la llamada a un mtodo, se
ejecuta el mtodo de la clase base independientemente del objeto referenciado por
el apuntador. Este no es un comportamiento polimrfico.

- 294 -
Destructores virtuales

Cuando se aplica la instruccin delete a un apuntador de clase base, ser
ejecutado el destructor de la clase base sobre el objeto, independientemente de la
clase a la que pertenezca. La solucin es declarar al destructor de la clase base
como virtual. De esta forma al borrar a un objeto se ejecutar el destructor de la
clase a la que pertenezca el objeto referenciado, a pesar de que los destructores no
tengan el mismo nombre.

Un constructor no puede ser declarado como virtual.

Ejemplos de funciones virtuales y polimorfismo:

Programa de clculo de salario.
/ / EMPLEADO. H
/ / Abst r act base cl ass Empl oyee
#ifndef EMPLEADO_H_
#define EMPLEADO_H_

class Empl oyee {
public:
Empl oyee( const char *, const char *) ;
~Empl oyee( ) ;
const char *get Fi r st Name( ) const;
const char *get Last Name( ) const;

virtual float ear ni ngs( ) const = 0; / / vi r t ual pur a
virtual void pr i nt ( ) const = 0; / / vi r t ual pur a
private:
char *f i r st Name;
char *l ast Name;
};

#endif / *EMPLEADO_H_*/

- 295 -
/ / EMPLEADO. CPP
#include <st r i ng>
#include <asser t . h>
#include " empl eado. h"

Empl oyee: : Empl oyee( const char *f i r st , const char *l ast )
{
f i r st Name = new char[ st r l en( f i r st ) + 1 ] ;
asser t ( f i r st Name ! = 0) ;
st r cpy( f i r st Name, f i r st ) ;

l ast Name = new char[ st r l en( l ast ) + 1 ] ;
asser t ( l ast Name ! = 0) ;
st r cpy( l ast Name, l ast ) ;
}

Empl oyee: : ~Empl oyee( )
{
delete [ ] f i r st Name;
delete [ ] l ast Name;
}

const char *Empl oyee: : get Fi r st Name( ) const
{

return f i r st Name;
}

const char *Empl oyee: : get Last Name( ) const
{
return l ast Name;
}

- 296 -
/ / J EFE. H
/ / Cl ase dr i vada de empl eado

#ifndef J EFE_H_
#define J EFE_H_


class Boss : public Empl oyee {
public:
Boss( const char *, const char *, float = 0. 0) ;
void set Weekl ySal ar y( float) ;
virtual float ear ni ngs( ) const;
virtual void pr i nt ( ) const;
private:
float weekl ySal ar y;
};

#endif / *J EFE_H_*/

/ / J EFE. CPP
#include " j ef e. h"
Boss: : Boss( const char *f i r st , const char *l ast , float s)
: Empl oyee( f i r st , l ast )
{ weekl ySal ar y = s > 0 ? s : 0; }

void Boss: : set Weekl ySal ar y( float s)
{ weekl ySal ar y = s > 0 ? s : 0; }

float Boss: : ear ni ngs( ) const { return weekl ySal ar y; }

void Boss: : pr i nt ( ) const
{
cout << " \ n J ef e: " << get Fi r st Name( )
<< ' ' << get Last Name( ) ;
}

- 297 -
/ / COMI S. H
/ / Tr abaj ador por comi si n der i vado de Empl eado

#ifndef COMI S_H_
#define COMI S_H_

class Commi ssi onWor ker : public Empl oyee {
public:
Commi ssi onWor ker ( const char *, const char *,
float = 0. 0, float = 0. 0, int = 0) ;
void set Sal ar y( float) ;
void set Commi ssi on( float) ;
void set Quant i t y( int) ;
private:
float sal ar y; / / sal ar i o base por semana
float commi ssi on; / / comi si n por cada vent a
int quant i t y; / / cant i dad de el ement os vendi dos por
semana
};

#endif / *COMI S_H_*/

/ / COMI S. CPP
#include " comi s. h"

Commi ssi onWor ker : : Commi ssi onWor ker ( const char *f i r st ,
const char *l ast , float s, float c, int q)
{
sal ar y = s > 0 ? s : 0;
commi ssi on = c > 0 ? c : 0;
quant i t y = q > 0 ? q : 0;
}

- 298 -
void Commi ssi onWor ker : : set Sal ar y( float s)
{ sal ar y = s > 0 ? s : 0; }

void Commi ssi onWor ker : : set Commi ssi on( float c)
{ commi ssi on = c > 0 ? c : 0; }

void Commi ssi onWor ker : : set Quant i t y( int q)
{ quant i t y = q > 0 ? q : 0; }

float Commi ssi onWor ker : : ear ni ngs( ) const
{ return sal ar y + commi ssi on * quant i t y; }

void Commi ssi onWor ker : : pr i nt ( ) const
{
cout << " \ nTr abaj ador por comi si on: " << get Fi r st Name( )
<< ' ' << get Last Name( ) ;
}

/ / PI EZA. H
/ / Tr abaj ador por pi eza der i vado de Empl eado
#ifndef PI EZA_H_
#define PI EZA_H_


class Pi eceWor ker : public Empl oyee {
public:
Pi eceWor ker ( const char *, const char *,
float = 0. 0, int = 0) ;
void set Wage( float) ;
void set Quant i t y( int) ;
private:
float wagePer Pi ece; / / pago por cada pi eza
int quant i t y; / / pi ezas por semana
};

#endif / *PI EZA_H_*/
- 299 -

/ / PI EZA. CPP
#include " pi eza. h"

/ / Const r uct or f or cl ass Pi eceWor ker
Pi eceWor ker : : Pi eceWor ker ( const char *f i r st ,
const char *l ast , float w, int q)
{
wagePer Pi ece = w > 0 ? w : 0;
quant i t y = q > 0 ? q : 0;
}

void Pi eceWor ker : : set Wage( float w)
{ wagePer Pi ece = w > 0 ? w : 0; }

void Pi eceWor ker : : set Quant i t y( int q)
{ quant i t y = q > 0 ? q : 0; }

float Pi eceWor ker : : ear ni ngs( ) const
{ return quant i t y * wagePer Pi ece; }

void Pi eceWor ker : : pr i nt ( ) const {
cout << " \ n Tabaj ador por pi eza: " << get Fi r st Name( )
<< ' ' << get Last Name( ) ;
}

/ / HORA. H
/ / Tr abaj ador por hor a der i vado de Empl eado
#ifndef HORA_H_
#define HORA_H_


class Hour l yWor ker : public Empl oyee {
public:
Hour l yWor ker ( const char *, const char *,
- 300 -
float = 0. 0, float = 0. 0) ;
void set Wage( float) ;
void set Hour s( float) ;
private:
float wage; / / sal ar i o por hor a
float hour s; / / hor as t r abaj adas en l a semana
};

#endif / *HORA_H_*/

/ / HORA. CPP
#include " hor a. h"

Hour l yWor ker : : Hour l yWor ker ( const char *f i r st , const char
*l ast ,
float w, float h)
{
wage = w > 0 ? w : 0;
hour s = h >= 0 && h < 168 ? h : 0;
}

void Hour l yWor ker : : set Wage( float w) { wage = w > 0 ? w : 0; }

void Hour l yWor ker : : set Hour s( float h)
{ hour s = h >= 0 && h < 168 ? h : 0; }

float Hour l yWor ker : : ear ni ngs( ) const { return wage * hour s; }

void Hour l yWor ker : : pr i nt ( ) const
{
cout << " \ n Tr abaj ador por hor a: " << get Fi r st Name( )
<< ' ' << get Last Name( ) ;
}

- 301 -

/ / mai n. cpp
#include 
#include " j ef e. h"
#include " comi s. h"
#include " pi eza. h"
#include " hor a. h"

int mai n( ) {
/ / f or mat o de sal i da
cout << set i osf l ags( i os: : showpoi nt ) << set pr eci si on( 2) ;

Empl oyee *pt r ; / / apunt ador a cl ase base

Boss b( " J ohn" , " Smi t h" , 800. 00) ;
pt r = &b; / / apunt ador de cl ase base apunt ando a obj et o de
cl ase der i vada
pt r - >pr i nt ( ) ; / / l i gado di nmi co
cout << " ganado $" << pt r - >ear ni ngs( ) ; / / l i gado di nmi co
b. pr i nt ( ) ; / / l i gado est t i co
cout << " ganado $" << b. ear ni ngs( ) ; / / l i gado est t i co

Commi ssi onWor ker c( " Sue" , " J ones" , 200. 0, 3. 0, 150) ;
pt r = &c;
pt r - >pr i nt ( ) ;
cout << " ganado $" << pt r - >ear ni ngs( ) ;
c. pr i nt ( ) ;
cout << " ganado $" << c. ear ni ngs( ) ;

Pi eceWor ker p( " Bob" , " Lewi s" , 2. 5, 200) ;
pt r = &p;
pt r - >pr i nt ( ) ;
p. pr i nt ( ) ;
cout << " ganado $" << p. ear ni ngs( ) ;

Hour l yWor ker h( " Kar en" , " Pr eci o" , 13. 75, 40) ;
- 302 -
pt r = &h;
pt r - >pr i nt ( ) ;
h. pr i nt ( ) ;
cout << " ganado $" << h. ear ni ngs( ) ;

cout << endl ;
return 0;
}

- 303 -
Programa de figuras geomtricas con una interfaz abstracta Shape (Forma)

/ / Fi gur a. H
#ifndef f i gur a_H
#define f i gur a_H

class Shape {
public:
virtual float ar ea( ) const { return 0. 0; }
virtual float vol ume( ) const { return 0. 0; }
virtual void pr i nt ShapeName( ) const = 0; / / vi r t ual pur a
};

#endif

/ / Punt o. H
#ifndef PUNTO_H_
#define PUNTO_H_
#include " f i gur a. h"

class Poi nt : public Shape {
friend ost r eam&operator<<( ost r eam&, const Poi nt &) ;
public:
Poi nt ( float = 0, float = 0) ;
void set Poi nt ( float, float) ;
float get X( ) const { return x; }
float get Y( ) const { return y; }
virtual void pr i nt ShapeName( ) const { cout << " Punt o: " ; }
private:
float x, y;
};
#endif / *PUNTO_H_*/

/ / Punt o. CPP
#include " punt o. h"
Poi nt : : Poi nt ( float a, float b)
{
x = a;
- 304 -
y = b;
}

void Poi nt : : set Poi nt ( float a, float b)
{
x = a;
y = b;
}

ost r eam&operator<<( ost r eam&out put , const Poi nt &p)
{
out put << ' [ ' << p. x << " , " << p. y << ' ] ' ;
return out put ;
}

/ / Ci r cul o. H
#ifndef CI RCULO_H_
#define CI RCULO_H_


class Ci r cl e : public Poi nt {
friend ost r eam&operator<<( ost r eam&, const Ci r cl e &) ;
public:
Ci r cl e( float r = 0. 0, float x = 0. 0, float y = 0. 0) ;

void set Radi us( float) ;
float get Radi us( ) const;
virtual float ar ea( ) const;
virtual void pr i nt ShapeName( ) const { cout << " Ci r cul o: " ;
}
private:
float r adi us;
};
#endif / *CI RCULO_H_*/

/ / Ci r cul o. CPP
#include " ci r cul o. h"
- 305 -

: Poi nt ( a, b)
{ r adi us = r > 0 ? r : 0; }

void Ci r cl e: : set Radi us( float r ) { r adi us = r > 0 ? r : 0; }

float Ci r cl e: : get Radi us( ) const { return r adi us; }

float Ci r cl e: : ar ea( ) const { return 3. 14159 * r adi us * r adi us;
}

ost r eam&operator<<( ost r eam&out put , const Ci r cl e &c)
{
out put << ' [ ' << c. get X( ) << " , " << c. get Y( )
<< " ] ; Radi o=" << set i osf l ags( i os: : showpoi nt )
<< set pr eci si on( 2) << c. r adi us;

return out put ;
}

/ / Ci l i ndr o. H
#ifndef CI LI NDRO_H_
#define CI LI NDRO_H_


class Cyl i nder : public Ci r cl e {
friend ost r eam&operator<<( ost r eam&, const Cyl i nder &) ;
public:
Cyl i nder ( float h = 0. 0, float r = 0. 0,
float x = 0. 0, float y = 0. 0) ;

void set Hei ght ( float) ;
virtual float ar ea( ) const;
virtual float vol ume( ) const;
virtual void pr i nt ShapeName( ) const { cout << " Ci l i ndr o: " ;
}
private:
- 306 -
float hei ght ; / / al t ur a del ci l i ndr o
};
#endif / *CI LI NDRO_H_*/

/ / Ci l i ndr o. CPP
#include " ci l i ndr o. h"

Cyl i nder : : Cyl i nder ( float h, float r , float x, float y)
: Ci r cl e( r , x, y)
{ hei ght = h > 0 ? h : 0; }

void Cyl i nder : : set Hei ght ( float h)
{ hei ght = h > 0 ? h : 0; }

float Cyl i nder : : ar ea( ) const
{
return 2 * Ci r cl e: : ar ea( ) +
2 * 3. 14159 * Ci r cl e: : get Radi us( ) * hei ght ;
}

float Cyl i nder : : vol ume( ) const
{
float r = Ci r cl e: : get Radi us( ) ;
return 3. 14159 * r * r * hei ght ;
}

ost r eam&operator<<( ost r eam&out put , const Cyl i nder & c)
{
out put << ' [ ' << c. get X( ) << " , " << c. get Y( )
<< " ] ; Radi o=" << set i osf l ags( i os: : showpoi nt )
<< set pr eci si on( 2) << c. get Radi us( )
<< " ; Al t ur a=" << c. hei ght ;
return out put ;
}

- 307 -
/ / mai n. CPP

#include " f i gur a. h"
#include " ci l i ndr o. h"

int mai n( ) {
Poi nt poi nt ( 7, 11) ;
Ci r cl e ci r cl e( 3. 5, 22, 8) ;
Cyl i nder cyl i nder ( 10, 3. 3, 10, 10) ;

poi nt . pr i nt ShapeName( ) ; / / l i gado est t i co
cout << poi nt << endl ;

ci r cl e. pr i nt ShapeName( ) ;
cout << ci r cl e << endl ;

cyl i nder . pr i nt ShapeName( ) ;
cout << cyl i nder << " \ n\ n" ;
cout << set i osf l ags( i os: : showpoi nt ) << set pr eci si on( 2) ;
Shape *pt r ; / / apunt ador de cl ase base

/ / apunt ador de cl ase base r ef er enci ando obj et o de cl ase
der i vada
pt r = &poi nt ;
pt r - >pr i nt ShapeName( ) ; / / l i gado di nmi co
cout << " x = " << poi nt . get X( ) << " ; y = " << poi nt . get Y( )
<< " \ nAr ea = " << pt r - >ar ea( )
<< " \ nVol umen = " << pt r - >vol ume( ) << " \ n\ n" ;

pt r = &ci r cl e;
pt r - >pr i nt ShapeName( ) ;
cout << " x = " << ci r cl e. get X( ) << " ; y =" << ci r cl e. get Y( )
<< " \ nAr ea = " << pt r - >ar ea( )
<< " \ nVol umen = " << pt r - >vol ume( ) << " \ n\ n" ;

- 308 -
pt r = &cyl i nder ;
pt r - >pr i nt ShapeName( ) ; / / dynami c bi ndi ng
cout << " x = " << cyl i nder . get X( ) << " ; y = " <<
cyl i nder . get Y( )
<< " \ nAr ea = " << pt r - >ar ea( )
<< " \ nVol umen = " << pt r - >vol ume( ) << endl ;
return 0;
}

- 309 -
Clases Abstractas y Polimorfismo en Java

El polimorfismo es implementado en J ava a travs de clases derivadas y
clases abstractas.

Recordar: El polimorfismo se define como la capacidad de objetos de clases
diferentes, relacionados mediante herencia, a responder de forma distinta a una
misma llamada de un mtodo.

Al hacer una solicitud de un mtodo, a travs de una variable de referencia a
clase base para usar un mtodo, J ava determina el mtodo que corresponda al
objeto de la clase a la que pertenece, y no el mtodo de la clase base.

Los mtodos en J ava - a diferencia de C++- tienen este comportamiento por
default, debido a que cuando un mtodo es accesado por una referencia a una
clase base, y esta mantiene una referencia a un objeto de una clase derivada, el
programa determina en tiempo de ejecucin a que mtodo llamar, de acuerdo al
tipo de objeto al que se apunta.

Esto como ya se ha visto, se conoce como ligadura tarda y permite otro
nivel de reutilizacin de cdigo, resaltado por la simplificacin con respecto a
C++de no tener que declarar al mtodo como virtual.

Ejemplo:

/ / ej empl o Pr ueba
class base {
public void qui en( ) {
Syst em. out. pr i nt l n( " base" ) ;
}
}

class pr i mer a extends base {
Syst em. out. pr i nt l n( " pr i mer a" ) ;
- 310 -
}
}

class segunda extends base {
Syst em. out. pr i nt l n( " segunda" ) ;
}
}

class t er cer a extends base {

}

class cuar t a extends base {
/ *publ i c i nt qui en( ) { No se val e con un t i po de dat o
di f er ent e
Syst em. out . pr i nt l n( " cuar t a" ) ;
r et ur n 1;
}*/
}

public class Pr ueba {
base obj Base= new base( ) , pBase;
pr i mer a obj 1= new pr i mer a( ) ;
segunda obj 2= new segunda( ) ;
t er cer a obj 3= new t er cer a( ) ;
cuar t a obj 4= new cuar t a( ) ;

pBase=obj Base;
pBase. qui en( ) ;

pBase=obj 1;
pBase. qui en( ) ;

pBase=obj 2;
pBase. qui en( ) ;

pBase=obj 3;
pBase. qui en( ) ;
- 311 -

pBase=obj 4;
pBase. qui en( ) ;
}
}

Como se aprecia en el ejemplo anterior, en caso de que el mtodo no sea
redefinido, se ejecuta el mtodo de la clase base.

Es importante sealar que al igual que en C++- los mtodos que sean
redefinidos en clases derivadas, deben tener adems de la misma firma que
mtodo base, el mismo tipo de retorno. Si se declara en una clase derivada un
mtodo con otro tipo de dato como retorno, se generar un error en tiempo de
compilacin.

Clase abstracta y clase concreta en Java

Recordar: Una clase base abstracta, es aquella que es definida para
especificar caractersticas generales que van a ser aprovechadas por sus clases
derivadas, pero no se necesita instanciar a dicha superclase.

Sintaxis para una clase abstracta:

abstract class Cl aseAbst r act a {
/ / cdi go de l a cl ase
}

Adems, existe la posibilidad de contar con mtodos abstractos:

Un mtodo abstracto lleva la palabra revervada abstract y contiene slo el
nombre y su firma. No necesita implementarse, ya que esto es tarea de las
subclases.

- 312 -
Si una clase contiene al menos un mtodo abstracto, toda la clase es
considerada abstracta y debe de declararse como tal. Es posible claro, declarar a
una clase como abstracta sin que tenga mtodos abstractos.

Ejemplo bsico para un mtodo abstracto:

abstract class Cl aseAbst r act a {

public abstract void noTengoCodi go( int x) ;

}

Si se crea una subclase de una clase que contiene un mtodo abstracto,
deber de especificarse el cdigo de ese mtodo; de lo contrario, el mtodo
seguir siendo abstracto y por consecuencia tambin lo ser la subclase.
41

Aunque no se pueden tener objetos de clases abstractas, si se pueden tener
referencias a objetos de esas clases, permitiendo una manipulacin de objetos de
las clases derivadas mediante las referencias a la clase abstracta.

El uso de clases abstractas fortalece al polimorfismo, al poder partir de
clases definidas en lo general, sin implementacin de cdigo, pero pudiendo ser
agrupadas todas mediante variables de referencia a las clases base.

41
En C++, una clase se hace abstracta al declarar al menos uno de los mtodos virtuales como puro.
- 313 -
Ejemplos de clases abstractas y polimorfismo:

Programa de clculo de salario

/ / Cl ase base abst r act a Empl oyee

public abstract class Empl oyee {
private St r i ng f i r st Name;
private St r i ng l ast Name;

/ / Const r uct or
public Empl oyee( St r i ng f i r st , St r i ng l ast ) {
f i r st Name = new St r i ng ( f i r st ) ;
l ast Name = new St r i ng( l ast ) ;
}

public St r i ng get Fi r st Name( ) {
return new St r i ng( f i r st Name ) ;
}

public St r i ng get Last Name( ) {
return new St r i ng( l ast Name ) ;
}

/ / el met odo abst r act o debe de ser i mpl ement ado por cada
/ / cl ase der i vada de Empl oyee par a poder ser
/ / i nst anci adas l as subcl ases
public abstract double ear ni ngs( ) ;
}

/ / Cl ase Boss cl ass der i vada de Empl oyee

public final class Boss extends Empl oyee {
private double weekl ySal ar y;

public Boss( St r i ng f i r st , St r i ng l ast , double s) {
super( f i r st , l ast ) ; / / l l amada al const r uct or de
cl ase base
set Weekl ySal ar y( s ) ;
}
- 314 -

public void set Weekl ySal ar y( double s ) {
weekl ySal ar y = ( s > 0 ? s : 0 ) ;
}

/ / obt i ene pago del j ef e
public double ear ni ngs( ) {
return weekl ySal ar y;
}

return " J ef e: " + get Fi r st Name( ) + ' ' +
get Last Name( ) ;
}
}

/ / Cl ase Pi eceWor ker der i vada de Empl oyee

public final class Pi eceWor ker extends Empl oyee {
private double wagePer Pi ece; / / pago por pi eza
private int quant i t y; / / pi ezas por semana

public Pi eceWor ker ( St r i ng f i r st , St r i ng l ast ,
double w, int q ) {
set Wage( w ) ;
set Quant i t y( q ) ;
}

public void set Wage( double w ) {
wagePer Pi ece = ( w > 0 ? w : 0 ) ;
}

public void set Quant i t y( int q ) {
quant i t y = ( q > 0 ? q : 0 ) ;
}

return quant i t y * wagePer Pi ece;
}
- 315 -

return " Tr abaj ador por pi eza: " +
get Fi r st Name( ) + ' ' + get Last Name( ) ;
}
}

/ / Cl ase Hour l yWor ker der i vada de Empl oyee

public final class Hour l yWor ker extends Empl oyee {
private double wage; / / pago por hor a
private double hour s; / / hor as t r abaj adas por semana

public Hour l yWor ker ( St r i ng f i r st , St r i ng l ast ,
double w, double h ) {
set Wage( w ) ;
set Hour s( h ) ;
}

public void set Wage( double w ) {
wage = ( w > 0 ? w : 0 ) ;
}

public void set Hour s( double h ) {
hour s = ( h >= 0 && h < 168 ? h : 0 ) ;
}

return wage * hour s;
}

return " Tr abaj ador por hor a: " +
}
}

- 316 -

/ / Cl ase Commi ssi onWor ker der i vada de Empl oyee

public final class Commi ssi onWor ker extends Empl oyee {
private double sal ar y; / / sal ar i o base por semana
private double commi ssi on; / / mont o por pr oduct o vendi do
private int quant i t y; / / t ot al de pr oduct os vendi dos
por semana

public Commi ssi onWor ker ( St r i ng f i r st , St r i ng l ast ,
double s, double c, int q) {
set Sal ar y( s ) ;
set Commi ssi on( c ) ;
set Quant i t y( q ) ;
}

public void set Sal ar y( double s ) {
sal ar y = ( s > 0 ? s : 0 ) ;
}

public void set Commi ssi on( double c ) {
commi ssi on = ( c > 0 ? c : 0 ) ;
}

public void set Quant i t y( int q ) {
quant i t y = ( q > 0 ? q : 0 ) ;
}

return sal ar y + commi ssi on * quant i t y;
}

return " Tr abaj ador por Comi si on : " +
}
}

- 317 -
/ / Pr ogr ama de ej empl o Pol i mor f i smo

public class Pol i mor f i smo {
public static void mai n( St r i ng r gs[ ] ) {

Empl oyee r ef ; / / r ef er enci a de cl ase base
Boss b;
Commi ssi onWor ker c;
Pi eceWor ker p;
Hour l yWor ker h;

b = new Boss( " Vi cent e" , " Fox" , 800. 00 ) ;
c = new Commi ssi onWor ker ( " Rosar i o" , " Robl es" ,
400. 0, 3. 0, 150) ;
p = new Pi eceWor ker ( " Andr es Manuel " , " Lopez Obr ador " ,
2. 5, 200 ) ;
h = new Hour l yWor ker ( " Er nest o" , " Zedi l l o" , 13. 75, 40
) ;

r ef = b; / / r ef er enci a de super cl ase a obj et o de
subcl ase
Syst em. out. pr i nt l n( r ef . t oSt r i ng( ) + " gano $" +
r ef . ear ni ngs( ) ) ;
Syst em. out. pr i nt l n( b. t oSt r i ng( ) + " gano $" +
b. ear ni ngs( ) ) ;

r ef = c; / / r ef er enci a de super cl ase a obj et o de
subcl ase
Syst em. out. pr i nt l n( c. t oSt r i ng( ) + " gano $" +
c. ear ni ngs( ) ) ;

r ef = p; / / r ef er enci a de super cl ase a obj et o de
subcl ase
Syst em. out. pr i nt l n( p. t oSt r i ng( ) + " gano $" +
p. ear ni ngs( ) ) ;

- 318 -
r ef = h; / / r ef er enci a de super cl ase a obj et o de
subcl ase
Syst em. out. pr i nt l n( h. t oSt r i ng( ) + " gano $" +
h. ear ni ngs( ) ) ;
}
}

- 319 -
Programa de figuras geomtricas con una clase abstracta Shape (Forma)

/ / Def i ni ci on de cl ase base abst r act a Shape

public abstract class Shape {

public double ar ea( ) {
return 0. 0;
}

public double vol ume( ) {
return 0. 0;
}

public abstract St r i ng get Name( ) ;
}

/ / Def i ni ci on de cl ase Poi nt

public class Poi nt extends Shape {
protected double x, y; / / coor denadas del punt o

public Poi nt ( double a, double b ) { set Poi nt ( a, b ) ; }

public void set Poi nt ( double a, double b ) {
x = a;
y = b;
}

public double get X( ) { return x; }

public double get Y( ) { return y; }

{ return " [ " + x + " , " + y + " ] " ; }

public St r i ng get Name( ) {
return " Punt o" ;
}
}
- 320 -

/ / Def i ni ci on de cl ase Ci r cl e

public class Ci r cl e extends Poi nt { / / her eda de Poi nt
protected double r adi us;

public Ci r cl e( ) {
super( 0, 0 ) ;
set Radi us( 0 ) ;
}

public Ci r cl e( double r , double a, double b ) {
super( a, b ) ;
set Radi us( r ) ;
}

public void set Radi us( double r )
{ r adi us = ( r >= 0 ? r : 0 ) ; }

public double get Radi us( ) { return r adi us; }

public double ar ea( ) { return 3. 14159 * r adi us * r adi us; }

{ return " Cent r o = " + super. t oSt r i ng( ) +
" ; Radi o = " + r adi us; }

return " Ci r cul o" ;
}
}

/ / Def i ni ci on de cl ase Cyl i nder

public class Cyl i nder extends Ci r cl e {
protected double hei ght ; / / al t ur a del ci l i ndr o

public Cyl i nder ( double h, double r , double a, double b )
{
super( r , a, b ) ;
- 321 -
set Hei ght ( h ) ;
}

public void set Hei ght ( double h ) {
hei ght = ( h >= 0 ? h : 0 ) ;
}

public double get Hei ght ( ) {
return hei ght ;
}

public double ar ea( ) {
return 2 * super. ar ea( ) +
2 * 3. 14159 * r adi us * hei ght ;
}

public double vol ume( ) {
return super. ar ea( ) * hei ght ;
}

return super. t oSt r i ng( ) + " ; Al t ur a = " + hei ght ;
}

return " Ci l i ndr o" ;
}
}

/ / Codi go de pr ueba

public class Pol i mor f i smo02 {

public static void mai n ( St r i ng ar gs [ ] ) {
Poi nt poi nt ;
Ci r cl e ci r cl e;
Cyl i nder cyl i nder ;
Shape ar r ayOf Shapes[ ] ;

poi nt = new Poi nt ( 7, 11 ) ;
- 322 -
ci r cl e = new Ci r cl e( 3. 5, 22, 8 ) ;
cyl i nder = new Cyl i nder ( 10, 3. 3, 10, 10 ) ;

ar r ayOf Shapes = new Shape[ 3 ] ;

/ / asi gno l as r ef er enci as de l os obj et os de subcl ase
/ / a un ar r egl o de super cl ase
ar r ayOf Shapes[ 0 ] = poi nt ;
ar r ayOf Shapes[ 1 ] = ci r cl e;
ar r ayOf Shapes[ 2 ] = cyl i nder ;

Syst em. out. pr i nt l n( poi nt . get Name( ) + " : " +
poi nt . t oSt r i ng( ) ) ;

Syst em. out. pr i nt l n( ci r cl e. get Name( ) + " : " +
ci r cl e. t oSt r i ng( ) ) ;

Syst em. out. pr i nt l n( cyl i nder . get Name( ) + " : " +
cyl i nder . t oSt r i ng( ) ) ;

for ( int i = 0; i < 3; i ++ ) {
Syst em. out. pr i nt l n( ar r ayOf Shapes[ i ] . get Name( ) +
" : " + ar r ayOf Shapes[ i ] . t oSt r i ng( ) ) ;
Syst em. out. pr i nt l n( " Ar ea = " + ar r ayOf Shapes[ i
] . ar ea( ) ) ;
Syst em. out. pr i nt l n( " Vol ume = " + ar r ayOf Shapes[ i
] . vol ume( ) ) ;
}
}
}

- 323 -
Ejempl o de Polimorfi smo con una Interfaz en Java

Los programas anteriores estaban basados en clases y clases abstractas. Sin
embargo, tambin es posible tener variables de referencia a interfaces, a travs de
las cuales se implemente el polimorfismo. El siguiente programa muestra otra
estructura clsica de clases grficas, todas contienen su propia implementacin
de draw(), y son organizadas en dos arreglos de ejemplo: uno de la clase
principal, y el segundo del tipo de la interfaz.

Ejemplo:

/ / pr ogr ama Pol i mor f i smo
interface I Dr awabl e {
void dr aw( ) ;
}

class Shape implements I Dr awabl e {
public void dr aw( ) { Syst em. out. pr i nt l n( " Di buj ando
Fi gur a. " ) ; }
}

- 324 -
class Ci r cl e extends Shape {
Ci r cul o. " ) ; }
}

class Rect angl e extends Shape {
Rect angul o. " ) ; }
}

class Squar e extends Rect angl e {
cuadr ado. " ) ; }
}

class Map implements I Dr awabl e {
mapa. " ) ; }
}

public class Pol i mor f i smo03 {
Shape[ ] shapes = {new Ci r cl e( ) , new Rect angl e( ) , new
Squar e( ) };
I Dr awabl e[ ] drawables = {new Shape( ) , new Rect angl e( ) ,
new Map( ) };

Syst em. out. pr i nt l n( " Di buj ando f i gur as: " ) ;
for ( int i = 0; i < shapes. l engt h; i ++)
shapes[ i ] . dr aw( ) ;

Syst em. out. pr i nt l n( " Di buj ando el ement os di buj abl es: " ) ;
for ( int i = 0; i < dr awabl es. l engt h; i ++)
dr awabl es[ i ] . dr aw( ) ;
}
}

- 325 -
Polimorfismo en Ruby

El polimorfismo es implementado en Ruby a travs de clases derivadas.

Recordar de nuevo: El polimorfismo se define como la capacidad de objetos de
clases diferentes, relacionados mediante herencia, a responder de forma distinta a
una misma llamada de un mtodo.

Al hacer una solicitud de un mtodo, a travs de una variable, Ruby
determina en tiempo de ejecucin a que mtodo llamar, de acuerdo al tipo de
objeto al que se apunta.

Ejemplo:

#ejemplo Prueba
class Base
def qui en
put s " base"
end
end

class Pr i mer a < Base
def qui en
put s " pr i mer a"
end
end

class Segunda < Base
def qui en
put s " segunda"
end
end

class Ter cer a < Base

end

- 326 -
class Cuar t a < Base
def qui en #Si se vale con un tipo de retorno diferente
(definido dinamicamente)
put s " cuar t a"
return 1
end
end

#codigo de prueba
def pr ueba
obj Base= Base. new
obj 1= Pr i mer a. new
obj 2= Segunda. new
obj 3= Ter cer a. new
obj 4= Cuar t a. new

pBase=obj Base
pBase. qui en

pBase=obj 1
pBase. qui en

pBase=obj 2
pBase. qui en

pBase=obj 3
pBase. qui en

pBase=obj 4
pBase. qui en
end

pr ueba

Como se aprecia en el ejemplo anterior, en caso de que el mtodo no sea
redefinido, se ejecuta el mtodo de la clase base.

Es importante sealar que no es necesario que el tipo de retorno coincida,
pues ste se determina dinmicamente.
- 327 -

Y la cl ase abstracta?

Ruby no tiene el concepto de clase abstracta y clase concreta. Si por cuestin de
diseo es necesario definir una clase que no debe permitir instancias, es posible
crear un mtodo en dicha clase como sigue:

class Mi Cl ase
def self. abst r act ?
return self == Mi Cl ase
end
end

Esto no limita realmente a que alguien pueda instanciar la clase, pero es
posible preguntar si la clase es abstract?.
- 328 -
Ejemplos de polimorfismo:

Programa de clculo de salario

# Clase base Employee

class Empl oyee
attr_reader :firstName, :lastName

@f i r st Name
@l ast Name

return self == Empl oyee
end

# Inicializador
def i ni t i al i ze ( f i r st , l ast )
@f i r st Name = St r i ng. new( f i r st )
@l ast Name = St r i ng. new( l ast )
end

# mtodo sin cdigo
def ear ni ngs
end
end

# Clase Boss cderivada de Employee

class Boss < Empl oyee
@weekl ySal ar y

def i ni t i al i ze ( f i r st , l ast , s)
super( f i r st , l ast ) # llamada al constructor de
clase base
set Weekl ySal ar y( s )
end

def set Weekl ySal ar y( s )
@weekl ySal ar y = ( s > 0 ? s : 0 )
- 329 -
end

# obtiene pago del jefe
def ear ni ngs
return @weekl ySal ar y
end

def t o_s
return " J ef e: " + @f i r st Name + " " + @l ast Name
end
end

# Clase PieceWorker derivada de Employee

class Pi eceWor ker < Empl oyee
attr_reader :wagePerPiece, :quantity

@wagePer Pi ece # pago por pieza
@quant i t y # piezas por semana

def i ni t i al i ze( f i r st , l ast , w, q )
super( f i r st , l ast )
set Wage( w )
set Quant i t y( q )
end

def set Wage( w )
@wagePer Pi ece = ( w > 0 ? w : 0 )
end

def set Quant i t y( q )
@quant i t y = ( q > 0 ? q : 0 )
end

def ear ni ngs
return quant i t y * wagePer Pi ece
end

def t o_s
return " Tr abaj ador por pi eza: " + @f i r st Name + " " +
- 330 -
@l ast Name
end
end

# Clase HourlyWorker derivada de Employee

class Hour l yWor ker < Empl oyee
attr_reader :wage, :hours

@wage # pago por hora
@hour s # horas trabajadas por semana

def i ni t i al i ze( f i r st , l ast , w, h)
set Wage( w )
set Hour s( h )
end

def set Wage( w )
@wage = ( w > 0 ? w : 0 )
end

def set Hour s( h )
@hour s = ( h >= 0 && h < 168 ? h : 0 )
end

def ear ni ngs
return @wage * @hour s
end

def t o_s
return " Tr abaj ador por hor a: " + @f i r st Name + " " +
@l ast Name
end
end

# Clase CommissionWorker derivada de Employee

class Commi ssi onWor ker < Empl oyee
- 331 -
attr_reader :salary, :commission, :quantity

@sal ar y # salario base por semana
@commi ssi on # monto por producto vendido
@quant i t y # total de productos vendidos por semana

def i ni t i al i ze( f i r st , l ast , s, c, q)
set Sal ar y( s )
set Commi ssi on( c )
set Quant i t y( q )
end

def set Sal ar y( s )
@sal ar y = ( s > 0 ? s : 0 )
end

def set Commi ssi on( c )
@commi ssi on = ( c > 0 ? c : 0 )
end

def set Quant i t y( q )
@quant i t y = ( q > 0 ? q : 0 )
end

def ear ni ngs
return @sal ar y + @commi ssi on * @quant i t y
end

def t o_s
return " Tr abaj ador por Comi si on : " + @f i r st Name + " "
+ @l ast Name
end
end

# Codigo de ejemplo Polimorfismo

b = Boss. new( " Vi cent e" , " Fox" , 800. 00 )
c = Commi ssi onWor ker . new( " Rosar i o" , " Robl es" , 400. 0, 3. 0,
- 332 -
150)
p = Pi eceWor ker . new( " Andr es Manuel " , " Lopez Obr ador " , 2. 5,
200 )
h = Hour l yWor ker . new( " Er nest o" , " Zedi l l o" , 13. 75, 40 )

put s Empl oyee. abst r act ?

r ef = b # referencia a objeto de subclase
put s r ef . t o_s + " gano $" + r ef . ear ni ngs. t o_s
put s b. t o_s + " gano $" + b. ear ni ngs. t o_s

r ef = c # referencia a objeto de subclase
put s c. t o_s + " gano $" + c. ear ni ngs. t o_s

r ef = p # referencia a objeto de subclase
put s p. t o_s + " gano $" + p. ear ni ngs. t o_s

r ef = h # referencia a objeto de subclase
put s h. t o_s + " gano $" + h. ear ni ngs. t o_s

- 333 -
Programa de figuras geomtricas con una clase abstracta Shape (Forma)

# Definicion de clase base abstracta Shape

class Shape
return self == Shape
end

def ar ea
return 0. 0
end

def vol ume
return 0. 0
end

def get Name
end

end

# Definicion de clase Point

class Poi nt < Shape
attr_reader :x, :y

@x
@y # coordenadas del punto

def i ni t i al i ze ( a, b)
set Poi nt ( a, b )
end

def set Poi nt ( a, b)
@x, @y = a, b
end

def t o_s
return " [ " + @x. t o_s + " , " + @y. t o_s + " ] "
- 334 -
end

def get Name
return " Punt o"
end
end

# Definicion de clase Circle
class Ci r cl e < Poi nt # hereda de Point
attr_reader :radius

@r adi us

def i ni t i al i ze( r , a, b)
super( a, b )
set Radi us( r )
end

def set Radi us( r )
@r adi us = ( r >= 0 ? r : 0 )
end

def ar ea
return 3. 14159 * r adi us * r adi us
end

def t o_s
return " Cent r o = " + super + " ; Radi o = " +
@r adi us. t o_s
end

def get Name
return " Ci r cul o "
end
end

# Definicion de clase Cylinder
class Cyl i nder < Ci r cl e
attr_reader :height
alias_method :areaCircle, :area #define un nuevo nombre
- 335 -
para el metodo area de Circle
# o puede usarse alias :areaCircle :area

@hei ght # altura del cilindro

def i ni t i al i ze( h, r , a, b)
super( r , a, b)
set Hei ght ( h)
end

def set Hei ght ( h)
@hei ght = ( h >= 0 ? h : 0 )
end

def ar ea
return 2 * super + 2 * 3. 14159 * @r adi us * @hei ght
end

def vol ume
return ar eaCi r cl e * @hei ght
end

def t o_s
return super + " ; Al t ur a = " + @hei ght . t o_s
end

def get Name
return " Ci l i ndr o "
end
end

# Codigo de prueba

poi nt = Poi nt . new( 7, 11 )
ci r cl e = Ci r cl e. new( 3. 5, 22, 8 )
cyl i nder = Cyl i nder . new( 10, 3. 3, 10, 10 )

# asigno las referencias de los objetos de subclase
# a un arreglo
- 336 -
ar r ayOf Shapes=[ ]
ar r ayOf Shapes[ 0 ] = poi nt
ar r ayOf Shapes[ 1 ] = ci r cl e
ar r ayOf Shapes[ 2 ] = cyl i nder

put s poi nt . get Name + " : " + poi nt . t o_s

put s ci r cl e. get Name + " : " + ci r cl e. t o_s

put s cyl i nder . get Name + " : " + cyl i nder . t o_s

for el emin ar r ayOf Shapes
put s el em. get Name + el em. t o_s
put s " Ar ea = " + el em. ar ea. t o_s
put s " Vol umen = " + el em. vol ume. t o_s
end

- 337 -
Plantillas de clase en C++

El concepto de plantillas es aplicable tambin a la programacin orientada a
objetos en C++a travs de plantillas de clase. Estas favorecen la reutilizacin de
software, permitiendo que se generen objetos especficos para un tipo a partir de
clases genricas. Las plantillas de clase tambin son llamadas clases
parametrizadas.

El uso de plantillas de clase no es diferente al uso de plantillas en
operaciones no orientadas a objetos:

template <class T> template <typename T>

Veamos el ejemplo clsico de un programa de pila aprovechando el uso de
plantillas.

Ejemplo:

/ / st ack. h
/ / Cl ase de pl ant i l l a Pi l a
#ifndef STACK_H_
#define STACK_H_

/ / #i ncl ude 

template< class T >
class St ack {
public:
St ack( int = 10 ) ;
~St ack( ) { delete [ ] st ackPt r ; }
char push( const T& ) ;
char pop( T& ) ;
private:
int si ze;
int t op;
T *st ackPt r ;

- 338 -
char i sEmpt y( ) const { return t op == - 1; }
char i sFul l ( ) const { return t op == si ze - 1; }
};

template< class T >
St ack< T >: : St ack( int s )
{
si ze = s > 0 ? s : 10;
t op = - 1;
st ackPt r = new T[ si ze ] ;
}

template< class T >
char St ack< T >: : push( const T &pushVal ue )
{
if ( ! i sFul l ( ) ) {
st ackPt r [ ++t op ] = pushVal ue;
return 1;
}
return 0;
}

template< class T >
char St ack< T >: : pop( T &popVal ue )
{
if ( ! i sEmpt y( ) ) {
popVal ue = st ackPt r [ t op- - ] ;
return 1;
}
return 0;
}

#endif / *STACK_H_*/

- 339 -
/ / Ej empl o uso de pl ant i l l as de cl ase
#include " st ack. h"


int mai n( ) {
St ack< double > doubl eSt ack( 5 ) ;
double f = 1. 1;
cout << " I nser t ando el ement os en doubl eSt ack \ n" ;

while ( doubl eSt ack. push( f ) ) {
cout << f << ' ' ;
f += 1. 1;
}

cout << " \ nLa pi l a est l l ena. No se puede i nser t ar el
el ement o " << f
<< " \ n\ nSacando el ement os de doubl eSt ack\ n" ;

while ( doubl eSt ack. pop( f ) )
cout << f << ' ' ;

cout << " \ nLa pi l a est vac a. No se pueden el i mi nar ms
el ement os\ n" ;

St ack< int > i nt St ack;
int i = 1;
cout << " \ nI nser t ando el ement os en i nt St ack\ n" ;

while ( i nt St ack. push( i ) ) {
cout << i << ' ' ;
++i ;
}

cout << " \ nLa pi l a est l l ena. " << i
<< " \ n\ nSacando el ement os de i nt St ack\ n" ;

while ( i nt St ack. pop( i ) )
cout << i << ' ' ;
- 340 -

cout << " \ nLa pi l a est vac a. No se pueden el i mi nar ms
el ement os \ n" ;
return 0;
}

Las plantillas de clase ayudan a la reutilizacin de cdigo, al permitir varias
versiones de clases para un tipo de dato a partir de clases genricas. A estas clases
especficas se les conoce como clases de plantilla.

Con respecto a la herencia en combinacin con el uso de plantillas, se deben
tener en cuenta las siguientes situaciones [21]:

Una plantilla de clase se puede derivar de una clase de plantilla.

Una plantilla de clase se puede derivar de una clase que no sea plantilla.

Una clase de plantilla se puede derivar de una plantilla de clase.

Una clase que no sea de plantilla se puede derivar de una plantilla de clase.

En cuanto a los miembros estticos, cada clase de plantilla que se crea a
partir de una plantilla de clases mantiene sus propias copias de los miembros
estticos.
- 341 -
Standard Template Library (STL)

Las plantillas de clase son una herramienta muy poderosa en C++. Esto ha
llevado a desarrollar lo que se conoce como STL. STL es el acrnimo de
Standard Template Library, y es una libreria de C++que proporciona un conjunto
de clases contenedoras, iteradores y de algoritmos genericos:

Las clases contenedoras incluyen vectores, listas, deques, conjuntos,
multiconjuntos, multimapas, pilas, colas y colas de prioridad.
Los iteradotes son generalizaciones de apuntadores: son objetos que apuntan
a otros objetos. Son usados normalmente para iterar sobre un conjunto de
objetos. Los iteradotes son importantes porque son tipicamente usados como
interfaces entre las clases contenedores y los algoritmos.
Los algoritmos genricos incluyen un amplio rango de algoritmos
fundamentales para los ms comunes tipos de manipulacin de datos, como
ordenamiento, bsqueda, copiado y transformacin.
STL es una biblioteca estandar de ANSI/ISO desde julio de 1994.

La STL est altamente parametrizada, por lo que casi cada componente en la STL
es una plantilla [22]. Podemos usar por ejemplo la plantilla vect or <T> para
hacer uso de vectores sin necesidad de preocuparnos del manejo de memoria:

vect or <int> v( 3) ; / / Decl ar a un vect or de 3 el ement os.
v[ 0] = 7;
v[ 1] = v[ 0] + 3;
v[ 2] = v[ 0] + v[ 1] ; / / v[ 0] == 7, v[ 1] == 10, v[ 2] == 17

Los algoritmos proporcionados por la STL ayudan a manipular los datos de los
contenedores [22]. Por ejemplo, podemos invertir el orden de los elementos de un
vector, usando el algoritmo reverse():

r ever se( v. begi n( ) , v. end( ) ) ; / / v[ 0] ==17, v[ 1] ==10, v[ 2] ==7

- 342 -
Ejemplo:

#ifndef STACK_HPP_
#define STACK_HPP_
#include <vect or >

template <typename T>
class St ack {
private:
st d: : vect or <T> el ems; / / el ement os

public:
void push( T const&) ;
void pop( ) ;
T t op( ) const; / / r egr esa el ement o en el t ope
bool empt y( ) const { / / r egr esa si l a pi l a est a vaci a
return el ems. empt y( ) ;
}
};

void St ack<T>: : push ( T const& el em)
{
el ems. push_back( el em) ; / / aade una copi a de el em
}

template<typename T>
void St ack<T>: : pop ( )
{
if ( el ems. empt y( ) ) {
st d: : cout <<" St ack<>: : pop( ) : pi l a vaci a" ;
return;
}
el ems. pop_back( ) ; / / r emueve el ul t i mo el ement o
}

T St ack<T>: : t op ( ) const
{
if ( el ems. empt y( ) ) {
- 343 -
st d: : cout <<" St ack<>: : t op( ) : pi l a vaci a" ;
}
return el ems. back( ) ; / / r egr esa copi a del el ement o en
el t ope
}
#endif / *STACK_HPP_*/

#include <st r i ng>
#include <cst dl i b>
#include " st ack. hpp"

int mai n( )
{
St ack<int> i nt St ack; / / pi l a de ent er os
St ack<st d: : st r i ng> st r i ngSt ack; / / pi l a de st r i ngs

/ / mani pul api l a de ent er os
i nt St ack. push( 7) ;
st d: : cout << i nt St ack. t op( ) << st d: : endl ;

/ / mani pul a pi l a de st r i ngs
st r i ngSt ack. push( " hol a" ) ;
st d: : cout << st r i ngSt ack. t op( ) << st d: : endl ;
st r i ngSt ack. pop( ) ;
st r i ngSt ack. pop( ) ;
}

- 344 -
Clases Genricas en Java

J ava 1.5 introdujo finalmente el uso de clases genricas (generics) [23]. El
uso de clases genricas es una caracterstica poderosa usada en otros lenguajes,
siendo C++el ejemplo ms conocido que soporta programacin genrica
mediante el uso de plantillas o templates.

Sintaxis:

class Nombr eCl ase <Li st a de par met r os de t i pos> { }

Ejemplo:

class Pai r <T, U> {
private final T f i r st ;
private final U second;
public Pai r ( T f i r st , U second) { this. f i r st =f i r st ;
this. second=second; }
public T get Fi r st ( ) { return f i r st ; }
public U get Second( ) { return second; }
}

public class Pai r Exampl e {

Pai r <St r i ng, I nt eger > pai r = new Pai r <St r i ng,
I nt eger >( " one" , 2) ;

/ / no acept a t i pos de dat os bsi cos o pr i mi t i vos
/ / Pai r <St r i ng, i nt > pai r 2 = new Pai r <St r i ng,
I nt eger >( " one" , 2) ;

/ / si gui ent e l i nea gener ar a un war ni ng de segur i dad
de t i pos
/ / Pai r <St r i ng, I nt eger > pai r 3 = new Pai r ( " one" , 2) ;

Syst em. out. pr i nt l n( " Obt n pr i mer el ement o: " +
pai r . get Fi r st ( ) ) ;
- 345 -
Syst em. out. pr i nt l n( " Obt n segundo el ement o: " +
pai r . get Second( ) ) ;
}
}

Un error comn es olvidar los parmetros de tipo al invocar el constructor:

Pai r <St r i ng, I nt eger > pai r = new Pai r ( " one" , 2) ;

Esto produce un warning pero no un error. Es legal pero Pair es tomado como un
tipo crudo (raw type)
42
, pero la conversin de ese tipo de dato al tipo
parametrizado es lo que genera el warning.

Es tambin posible parametrizar interfaces, como se muestra a continuacin.

Sintaxis:

interface Nombr eI nt er f az <Li st a de par met r os de t i pos> { }

Ejemplo:

interface I Pai r <T, U>{
public T get Fi r st ( ) ;
public U get Second( ) ;
}

class Pai r <T, U> implements I Pai r <T, U>{
private final T f i r st ;
private final U second;
public Pai r ( T f i r st , U second) { this. f i r st =f i r st ;
this. second=second; }
public T get Fi r st ( ) { return f i r st ; }
public U get Second( ) { return second; }
}

42
Un raw type es un tipo especial de dato creado para facilitar la transicin de cdigo antiguo al nuevo
cdigo soportando Generics.
Ver: http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#110257
- 346 -
public class Pai r Exampl e {

I Pai r <St r i ng, I nt eger > i pai r = new Pai r <St r i ng,
I nt eger >( " one" , 2) ;

Syst em. out. pr i nt l n( " Obt n pr i mer
el ement o: " +i pai r . get Fi r st ( ) ) ;
Syst em. out. pr i nt l n( " Obt n segundo
el ement o: " +i pai r . get Second( ) ) ;
}

}

Un requerimiento para el uso tipos genricos en J ava es que no pueden usarse tipo
de datos primitivos, porque los tipos primitivos o bsicos no son subclases de
Object [24]. Por lo que sera ilegal por ejemplo querer instanciar Pai r . La ventaja es que el uso de la clase Object significa que solo un
archivo de clase (.class) necesita ser generado por cada clase genrica [25].

- 347 -

Biblioteca de Clases Genricas en Java

Al igual que C++con la STL, J ava tiene un conjunto de clases genricas
predefinidas. Su uso, al igual con las clases genricas definidas por el
programador, no esta permitido para tpos primitivos, por lo que solo objetos
podrn ser contenidos. Las principales clases genricas en J ava son, como en la
STL, clases contenedoras o collecciones
43
. El Java Collections Framework (J CF)
es un conjunto de interfaces y clases definidos en los paquetes j ava. ut i l y
j ava. ut i l . concur r ent .

Las interfaces del J CF son:

Collection. Contiene la funcionalidad bsica requerida en casi cualquier
coleccin de objetos (con excepcin de Map)
Set. Es una coleccin sin duplicados, donde el orden es no significante. Sin
embargo contiene un mtodo que devuelve el conjunto ordenado
(SortedSet).
Queue. Define el comportamiento bsico de una estructura de cola.
List. Es una coleccin donde el orden es significativo, permitiendo adems
valores duplicados.
Map. Define una coleccin donde un valor clave es asociado para almacenar
y recuperar elementos.

La siguiente figura muestra las principales interfaces de la J CF [26]:

43
Las colecciones en Java eran implementadas antes de la versin 1.5 pero sin el uso de clases genricas. El
uso de versiones anteriores de colecciones con colecciones genricas es permitido por compatibilidad hacia
atrs pero debe tenerse especial cuidado pues hay situaciones que el compilador no puede validar.
- 348 -

Ejemplo:

/ / Usando l a i nt er f az Col l ect i on
import j ava. ut i l . Li st ;
import j ava. ut i l . Ar r ayLi st ;
import j ava. ut i l . Col l ect i on;
import j ava. ut i l . I t er at or ;

public class Col l ect i onTest {
private static final St r i ng[ ] colors =
{ " MAGENTA" , " RED" , " WHI TE" , " BLUE" , " CYAN" };
private static final St r i ng[ ] removeColors =
{ " RED" , " WHI TE" , " BLUE" };

/ / cr ea Ar r ayLi st , aade Col or s y l a mani pul a
public Col l ect i onTest ( ) {
Li st < St r i ng > l i st = new Ar r ayLi st < St r i ng >( ) ;
Li st < St r i ng > r emoveLi st = new Ar r ayLi st < St r i ng >( ) ;

/ / aade el ement os del ar r egl o col or s a l i st
for ( St r i ng col or : colors )
l i st . add( col or ) ;

/ / aade el ement os del ar r egl o r emoveCol or s a
r emoveLi st
- 349 -
for ( St r i ng col or : removeColors )
r emoveLi st . add( col or ) ;

Syst em. out. pr i nt l n( " Ar r ayLi st : " ) ;

/ / despl i ega cont eni do de l i st
for ( int count = 0; count < l i st . si ze( ) ; count ++ )
Syst em. out. pr i nt f ( " %s " , l i st . get ( count ) ) ;

/ / r emueve de l i st col or es cont eni dos en r emoveLi st
r emoveCol or s( l i st , r emoveLi st ) ;

Syst em. out. pr i nt l n( " \ n\ nAr r ayLi st despus de l l amar
r emoveCol or s: " ) ;

/ / despl i ega cont eni do de l i st
for ( St r i ng col or : l i st )
Syst em. out. pr i nt f ( " %s " , col or ) ;
} / / end Col l ect i onTest const r uct or

/ / r emueve col or es especi f i cados en col l ect i on2 de
col l ect i on1
private void r emoveCol or s(
Col l ect i on< St r i ng > col l ect i on1, Col l ect i on< St r i ng >
col l ect i on2 ) {
/ / obt i ene i t er at or
I t er at or < St r i ng > i t er at or = col l ect i on1. i t er at or ( ) ;

/ / mi ent r as col ecci n t i ene el ement os
while ( i t er at or . hasNext ( ) )
if ( col l ect i on2. cont ai ns( i t er at or . next ( ) ) )
i t er at or . r emove( ) ; / / r emueve col or act ual
}

new Col l ect i onTest ( ) ;
}

}
- 350 -
Manejo de Excepciones

Siempre se ha considerado importante el manejo de los errores en un
programa, pero no fue hasta que surgi el concepto de manejo de excepciones que
se dio una estructura ms formal para hacerlo.

El trmino de excepcin viene de la posibilidad de detectar eventos que no
forman parte del curso normal del programa, pero que de todas formas ocurren.

Un evento "excepcional" puede ser generado por una falla en la conexin a
red, un archivo que no puede encontrarse, o un acceso indebido en memoria. La
intencin de una excepcin es responder de manera dinmica a los errores, sin
que afecte gravemente la ejecucin de un programa, o que al menos se controle la
situacin posterior al error.

Cul es la ventaja con respecto al manejo comn de errores?

Normalmente, cada programador agrega su propio cdigo de manejo de
errores y queda revuelto con el cdigo del programa. El manejo de excepciones
indica claramente en que parte se encuentra el manejo de los errores, separndolo
del cdigo normal.

Adems, es posible recibir y tratar muchos de los errores de ejecucin y
tratarlos correctamente, como podra ser una divisin entre cero.

Se recomienda el manejo de errores para aquellas situaciones en las cuales
el programa necesita ayuda para recuperarse.

- 351 -
Manejo de Excepciones en C++

El manejo de excepciones en C++, involucra los siguientes elementos
sintcticos:

try. El bloque definido por la instruccin try, especifica el cdigo que
potencialmente podra generar un error que deba ser manejado por la
excepcin:

try
{
/ / i nst r ucci ones donde l as excepci ones
/ / pueden ser gener adas
}

throw: Esta instruccin seguida por una expresin de un cierto tipo, genera
una excepcin del tipo de la expresin. Esta instruccin debera ser
ejecutada dentro de algn bloque try, de manera directa o indirecta:

throw " Se gener a una excepci n de t i po char *" ;

catch: La instruccin catch va seguida de un bloque try. Catch define un
segmento de cdigo para tratar una excepcin (de un tipo) lanzada:

catch ( char *mensaj e)
{
/ / i nst r ucci ones donde l a excepci n
/ / t hr own char *
/ / ser pr ocesada
}

- 352 -
Ejemplo:

/ / except i ons

int mai n ( ) {
try
{
throw 20;
}
catch ( int e)
{
cout << " Una excepci n ocur r i . Nmer o: " << e << endl ;
}
return 0;
}

Excepci ones estandar en C++

La biblioteca estndar de C++proporciona una clase base diseada
especficamente para declarar objetos que pueden ser lanzados como excepciones.
La clase exception esta declarada en <exception> (en el espacio de nombres std).
La clase tiene entre otras cosas un mtodo virtual llamado what que regresa un
arreglo de caracteres y puede ser redefinida en clases derivadas para describir la
excepcin.

Ejemplo:

/ / excepci ones est ndar
#include <except i on>

class myexcept i on: public except i on
{
virtual const char* what ( ) const throw( )
{
- 353 -
return " Mi excepci n se ej ecut " ;
}
} myex;

int mai n ( ) {
try
{
throw myex;
}
catch ( except i on& e)
{
cout << e. what ( ) << endl ;
}
return 0;
}

Las clases de la biblioteca estndar implementan clases derivadas de la clase
exception para poder lanzar excepciones derivadas de esta clase.

Ejemplo:

/ / excepci n bad_al l oc
#include <except i on>

int mai n ( ) {
try
{
int* myar r ay= new int[ 1000] ;
}
catch ( except i on& e)
{
cout << " Excepci n est ndar : " << e. what ( ) << endl ;
}
return 0;
}
- 354 -
Manejo de Excepciones en Java

El modelo de excepciones de J ava es similar al de C y C++, pero mientras
en estos lenguajes no estamos obligados a manejar las excepciones, en J ava es
forzoso para el uso de ciertas clases; de lo contrario, el compilador generar un
error.

Cmo funci ona?

Muchas tipos de errores pueden provocar una excepcin, desde un
desbordamiento de memoria o un disco duro estropeado hasta un intento de
dividir por cero o intentar acceder a un arreglo fuera de sus lmites. Cuando esto
ocurre, la mquina virtual de J ava crea un objeto de la clase Exception Error y
se notifica el hecho al sistema de ejecucin. En este punto, se dice que se ha
lanzado una excepcin.

Un mtodo se dice que es capaz de tratar una excepcin si ha previsto el
error que se ha producido y prev tambin las operaciones a realizar para
recuperar el programa de ese estado de error.

En el momento en que es lanzada una excepcin, la mquina virtual de J ava
recorre la pila de llamadas de mtodos en busca de alguno que sea capaz de tratar
la clase de excepcin lanzada. Para ello, comienza examinando el mtodo donde
se ha producido la excepcin; si este mtodo no es capaz de tratarla, examina el
mtodo desde el que se realiz la llamada al mtodo donde se produjo la
excepcin y as sucesivamente hasta llegar al ltimo de ellos. En caso de que
ninguno de los mtodos de la pila sea capaz de tratar la excepcin, la mquina
virtual de J ava muestra un mensaje de error y el programa termina.

Los programas escritos en J ava tambin pueden lanzar excepciones
explcitamente mediante la instruccin throw, lo que facilita la devolucin de un
cdigo de error al mtodo que invoc el mtodo que caus el error.

Un ejemplo de una excepcin generada (y no tratada) es el siguiente
programa:
- 355 -

public class Excepci on {
int i =5, j =0;
int k=i / j ; / / Di vi si n por cer o
}
}

Al ejecutarlo, se ver que la mquina virtual J ava ha detecta una condicin
de error y ha crea un objeto de la clase java.lang.ArithmeticException. Como el
mtodo donde se ha producido la excepcin no es capaz de tratarla, es manejada
por la mquina virtual J ava, que muestra un mensaje de error y finaliza la
ejecucin del programa.

Lanzamiento de excepci ones (throw)

Como se ha comentado anteriormente, un mtodo tambin es capaz de
lanzar excepciones.

Sintaxis:

mt odo ( ) throws <l i st a de excepci ones> {
/ / cdi go
. . .
throw new <nombr e Excepci n>
. . .
}

donde <lista de excepciones> es el nombre de cada una de las excepciones
que el mtodo puede lanzar.

Por ejemplo, en el siguiente programa se genera una condicin de error si el
dividendo es menor que el divisor:

- 356 -
Ejemplo:

public class LanzaExcepci on {
public static void mai n( St r i ng ar gument os[ ] ) throws
Ar i t hmet i cExcept i on {

int i =1, j =0;
if ( j ==0)
throw new Ar i t hmet i cExcept i on( ) ;
else
Syst em. out. pr i nt l n( i / j ) ;
}
}

Para lanzar la excepcin es necesario crear un objeto de tipo Exception o
alguna de sus subclases (por ejemplo: ArithmeticException) y lanzarlo mediante
la instruccin throw.

Los dos ejemplos vistos anteriormente, son capaces de lanzar una excepcin
en un momento dado, pero hasta aqu no difieren en mucho en su ejecucin, ya
que el resultado finalmente es la terminacin del programa. En la siguiente
seccin se menciona como podemos darles un manejo especial a las excepciones,
de tal forma que el resultado puede ser previsto por el programador.

Manej o de excepci ones

En J ava, de forma similar a C++se pueden tratar las excepciones previstas
por el programador utilizando unos mecanismos, los manejadores de
excepciones, que se estructuran en tres bloques:

El bloque try.
El bloque catch.
El bloque finally.

Un manejador de excepciones es una porcin de cdigo que se va a encargar
de tratar las posibles excepciones que se puedan generar.
- 357 -

El bloque try

Lo primero que hay que hacer para que un mtodo sea capaz de tratar una
excepcin generada por la mquina virtual J ava o por el propio programa
mediante una instruccin throw, es encerrar las instrucciones susceptibles de
generarla en un bloque try.

try {

}

Cualquier excepcin que se produzca dentro del bloque try ser analizada
por el bloque o bloques catch que se ver en el punto siguiente. En el momento en
que se produzca la excepcin, se abandona el bloque try y, por lo tanto, las
instrucciones que sigan al punto donde se produjo la excepcin no sern
ejecutadas.

El bloque catch

Cada bloque try debe tener asociado por lo menos un bloque catch.

try {

} catch ( Ti poExcepci n1 nombr eVar i abl e1) {

} catch ( Ti poExcepci n2 nombr eVar i abl e2) {
}
. . .
catch ( Ti poExcepci nN nombr eVar i abl eN) {

}

Por cada bloque try pueden declararse uno o varios bloques catch, cada uno
de ellos capaz de tratar un tipo de excepcin.
- 358 -

Para declarar el tipo de excepcin que es capaz de tratar un bloque catch, se
declara un objeto cuya clase es la clase de la excepcin que se desea tratar o una
de sus superclases.

Ejemplo:

public class Excepci onTr at ada {
int i =5, j =0;
try {
int k=i / j ;
Syst em. out. pr i nt l n( " Est o no se va a ej ecut ar . " ) ;
}
catch ( Ar i t hmet i cExcept i on ex) {
Syst em. out. pr i nt l n( " Ha i nt ent ado di vi di r por
cer o" ) ;
}
Syst em. out. pr i nt l n( " Fi n del pr ogr ama" ) ;
}
}

La ejecucin se resuelve de la siguiente forma:

1. Cuando se intenta dividir por cero, la mquina virtual J ava genera un
objeto de la clase ArithmeticException.
2. Al producirse la excepcin dentro de un bloque try, la ejecucin del
programa se pasa al primer bloque catch.
3. Si la clase de la excepcin se corresponde con la clase o alguna
subclase de la clase declarada en el bloque catch, se ejecuta el bloque
de instrucciones catch y a continuacin se pasa el control del
programa a la primera instruccin a partir de los bloques try-catch.

Tambin se podra haber utilizado en la declaracin del bloque catch, una
superclase de la clase ArithmeticException.

- 359 -
Por ejemplo:

catch ( Runt i meExcept i on ex)

catch ( Except i on ex)

Sin embargo, es mejor utilizar excepciones ms cercanas al tipo de error
previsto, ya que lo que se pretende es recuperar al programa de alguna condicin
de error y si tratan de capturar todas las excepciones de una forma muy general,
posiblemente habr que averiguar despus qu condicin de error se produjo para
poder dar una respuesta adecuada.

El bloque finally

El bloque finally se utiliza para ejecutar un bloque de instrucciones sea cual
sea la excepcin que se produzca. Este bloque se ejecutar en cualquier caso,
incluso si no se produce ninguna excepcin.

Este bloque garantiza que el cdigo que contiene ser ejecutado
independientemente de que se genere o no una excepcin:

try {

}
catch ( Ti poExcepci n1 nombr eVar i abl e1) {
}

catch ( Ti poExcepci n2 nombr eVar i abl e2) {
}
. . .
catch ( Ti poExcepci nN nombr eVar i abl eN) {

}
finally {

}
- 360 -

Es utilizado para no tener que repetir cdigo en el bloque try y en los
bloques catch. Este cdigo sirve para llevar a buen trmino el bloque de cdigo
independientemente del resultado.

Veamos ahora la clase ExcepcionTratada con el bloque finally:

public class Excepci onTr at ada {
int i =5, j =0;
try {
int k=i / * / j */ ; / / pr obar con y si n er r or
}
catch ( Ar i t hmet i cExcept i on ex) {
Syst em. out. pr i nt l n( " Ha i nt ent ado di vi di r por
cer o" ) ;
}
finally {
Syst em. out. pr i nt l n( " Sal i da de f i nal l y" ) ;
}
Syst em. out. pr i nt l n( " Fi n del pr ogr ama" ) ;
}
}

Un ejemplo derivando la clase Exception de J ava en un estilo similar al uso de la
clase correspondiente en C++:

class Di vi si onByZer oExcept i on extends Except i on {
Di vi si onByZer oExcept i on( St r i ng msg) { super( msg) ; }
}

public class Di vi si onByZer o {
public void di vi si on( ) throws Di vi si onByZer oExcept i on {
int num1 = 10;
int num2 = 0;

if ( num2 == 0)
throw new Di vi si onByZer oExcept i on( " / ent r e 0" ) ;
- 361 -
Syst em. out. pr i nt l n( num1 + " / " + num2 + " = " + ( num1
/ num2) ) ;
Syst em. out. pr i nt l n( " t er mi nando di vi si on( ) . " ) ;
}

try {
new Di vi si onByZer o( ) . di vi si on( ) ;
} catch ( Di vi si onByZer oExcept i on e) {
Syst em. out. pr i nt l n( " En mai n, t r at ando con " + e) ;
} finally {
Syst em. out. pr i nt l n( " Fi nal l y ej ecut ado en mai n. " ) ;
}
Syst em. out. pr i nt l n( " Fi nal i zando mai n. " ) ;
}
}

Jerarqua de excepci ones

Las excepciones son objetos pertenecientes a la clase Throwable o alguna
de sus subclases.

Dependiendo del lugar donde se produzcan existen dos tipos de excepciones:

1. Las excepciones sncronas no son lanzadas en un punto arbitrario del
programa sino que, en cierta forma, son previsibles en determinados puntos
del programa como resultado de evaluar ciertas expresiones o la invocacin
de determinadas instrucciones o mtodos.

2. Las excepciones asncronas pueden producirse en cualquier parte del
programa y no son tan previsibles. Pueden producirse excepciones
asncronas debido a dos razones:

La invocacin del mtodo stop() de la clase Thread que se est
ejecutando.

Un error interno en la mquina virtual J ava.
- 362 -

Dependiendo de si el compilador comprueba o no que se declare un
manejador para tratar las excepciones, se pueden dividir en:

1. Las excepciones comprobables son repasadas por el compilador J ava
durante el proceso de compilacin, de forma que si no existe un manejador
que las trate, generar un mensaje de error.

2. Las excepciones no comprobables son la clase RuntimeException y sus
subclases junto con la clase Error y sus subclases.

Tambin pueden definirse por el programador subclases de las excepciones
anteriores. Las ms interesantes desde el punto de vista del programador son las
subclases de la superclase Exception ya que stas pueden ser comprobadas por el
compilador.

La jerarqua completa de excepciones existentes en el paquete java.lang se
puede consultar ms adelante.
44

Ventajas del tratamiento de excepciones

Las ventajas, mencionadas por Daz-Alejo [27], de un mecanismo de
tratamiento de excepciones como este son varias:

Separacin del cdigo til del tratamiento de errores.
Propagacin de errores a travs de la pila de mtodos.
Agrupacin y diferenciacin de errores mediante jerarquas.
Claridad del cdigo y obligacin del tratamiento de errores.

44
Para un listado actual ver la documentacin del jdk de Java ms reciente.
- 363 -
Lista de Excepciones
45

La jerarqua de clases derivadas de Error existentes en el paquete java.lang
es la siguiente:

o java.lang.Object
o java.lang.Throwable (implements java.io.Serializable)
o java.lang.Error
o java.lang.AssertionError
o java.lang.LinkageError
o java.lang.ClassCircularityError
o java.lang.ClassFormatError
o java.lang.UnsupportedClassVersionError
o java.lang.ExceptionInInitializerError
o java.lang.IncompatibleClassChangeError
o java.lang.AbstractMethodError
o java.lang.IllegalAccessError
o java.lang.InstantiationError
o java.lang.NoSuchFieldError
o java.lang.NoSuchMethodError
o java.lang.NoClassDefFoundError
o java.lang.UnsatisfiedLinkError
o java.lang.VerifyError
o java.lang.ThreadDeath

45
Lista obtenida de la documentacin del jdk en su versin 1.6
- 364 -
o java.lang.VirtualMachineError
o java.lang.InternalError
o java.lang.OutOfMemoryError
o java.lang.StackOverflowError
o java.lang.UnknownError

La jerarqua de clases derivadas de Exception existentes en el paquete
java.lang es la siguiente:

o java.lang.Object
o java.lang.Throwable (implements java.io.Serializable)
o java.lang.Exception
o java.lang.ClassNotFoundException
o java.lang.CloneNotSupportedException
o java.lang.IllegalAccessException
o java.lang.InstantiationException
o java.lang.InterruptedException
o java.lang.NoSuchFieldException
o java.lang.NoSuchMethodException
o java.lang.RuntimeException
o java.lang.ArithmeticException
o java.lang.ArrayStoreException
o java.lang.ClassCastException
o java.lang.EnumConstantNotPresentException
o java.lang.IllegalArgumentException
- 365 -
o java.lang.IllegalThreadStateException
o java.lang.NumberFormatException
o java.lang.IllegalMonitorStateException
o java.lang.IllegalStateException
o java.lang.IndexOutOfBoundsException
o java.lang.ArrayIndexOutOfBoundsException
o java.lang.StringIndexOutOfBoundsException
o java.lang.NegativeArraySizeException
o java.lang.NullPointerException
o java.lang.SecurityException
o java.lang.TypeNotPresentException
o java.lang.UnsupportedOperationException

Las principales excepciones en otros paquetes J ava son:

o class java.lang.Object
o class java.lang.Throwable
o class java.lang.Error
o java.awt.AWTError
o class java.lang.Exception
o java.io.IOException
o java.io.EOFException
o java.io.FileNotFoundException
o java.io.InterruptedIOException
o java.io.UTFDataFormatException
o java.net.MalformedURLException
o java.net.ProtocolException
o java.net.SocketException
o java.net.UnknownHostException
- 366 -
o java.net.UnknownServiceException
o RuntimeException
o java.util.EmptyStackException
o java.util.NoSuchElementException
o java.awt.AWTException

- 367 -

Afirmaciones en Java

Las afirmaciones son usadas para verificar invariantes en un programa [28].
Es una manera simple de probar una condicin que siempre debe ser verdadera.
Si la afirmacin resulta ser falsa una excepcin es lanzada. Escribir afirmaciones
mientras se programa es una de las ms rpidas y efectivas formas de detectar y
corregir errores [29]. Las afirmaciones fueron introducidas en J ava desde la
versin 1.4 del jdk.

Las afirmaciones por lo tanto son usadas para comprobar cdigo que se
asume ser verdadero, siendo la afirmacin la parte responsable de verificar que
realmente es verdadero. Cada afirmacin debe contener una expresin boleana
(boolean o Boolean).

Sintaxis:

assert Expr essi on1;

:

assert Expr essi on1 : Expr essi on2 ;

donde Expr essi on1 es una expresin booleana. Esta expresin es la
evaluada y si es falsa la excepcin AssertionError es lanzada. Expr essi on2 es
una expresin que devuelve un valor (no void) que generalmente es usado para
proveer de un mensaje para la excepcin AssertionError.

Usando afirmaciones

Es importante no introducir cdigo en las afirmaciones que en realidad sea
una accin del programa. Por ejemplo:

- 368 -
assert ++i < max;

Es inapropiado pues se esta modificando el estado del programa al mismo
tiempo que validando. Lo correcto sera algo del estilo:

i ++;
assert i < max;

Errores detectados con afirmaciones deben ser errores que no deben pasar.
Es por esto que se lanza un subtipo de Error en lugar de un subtipo de Exception.
Si falla la validacin de una afirmacin se asume un error grave que nunca debe
pasar.

Habi litando y deshabili tando l as afirmaci ones

Por omisin, las afirmaciones estan deshabilitadas en tiempo de ejecucin.
Para cambiar de un estado a otro deben aplicarse parmetros especiales en la
ejecucin de la mquina virtual de J ava:

- enabl easser t i ons | - ea
- di sabl easser t i ons | - da

Estos modificadores pueden no llevar a su vez argumentos, por lo que active
o desactiva las afirmaciones para todas las clases, o pueden indicarse nombres de
paquetes clases especficas:

j ava [ - ea | - da] : [ paquet e | cl ase] Cl ase

Las clases del sistema no son directamente afectadas por estos
modificadores, lo que es deseable, por lo que si se quiere modificar esto se deben
usar:

- enabl esyst emasser t i ons | esa
- di sabl esyst emasser t i ons | - dsa.

- 369 -
Ejemplo:

/ / Recuer da habi l i t ar el uso de af i r maci ones
import j ava. i o. I OExcept i on;

public class Asser t i onTest {

public static void mai n( St r i ng ar gv[ ] ) throws I OExcept i on {
Syst em. out. pr i nt ( " I nt r oduce t u est ado ci vi l : " ) ;
int c = Syst em. in. r ead( ) ;
switch ( ( char) c) {
case ' s' :
case ' S' : Syst em. out. pr i nt l n( " Sol t er o" ) ; break;
case ' c' :
case ' C' : Syst em. out. pr i nt l n( " Casado" ) ; break;
case ' d' :
case ' D' : Syst em. out. pr i nt l n( " Di vor ci ado" ) ; break;
default: assert ! true: " Opci n i nvl i da" ; ; break;
}

}
}

- 370 -
Manejo de Excepciones en Ruby

Ruby soporta el manejo de excepciones como cualquier lenguaje actual de
programacin. El manejo de excepciones en Ruby, involucra los siguientes
elementos sintcticos:

Raise & Rescue

La ejecucin de raise produce una excepcin. raise es un mtodo del
mdulo Kernel y tiene un alias definido como fail. La sintaxis se presenta a
continuacin:

raise Except i onCl ass[ , " message" ]

Ejemplos:

raise # se relanza la ultima excepcion
raise " Danger , Wi l l Robi nson! "
raise Houst on, we have a pr obl em
raise Ar gument Er r or , " Fal l a de dat os"
raise Ar gument Er r or . new( " Fal l a de dat os" )
raise " Fal t a nombr e" if nombr e. nil?

Ahora, como agrupamos un segmento de cdigo en el cual se quieren manejar
excepciones? Podemos agrupar el cdigo usando un bloque begin end. Dentro
podemos incluir la clasula rescue, por ejemplo:

begin
expr . .
[ rescue [ t i po_de_er r or [ => var ] , . . ]
expr . . ] . .
[ else
expr . . ]
[ ensure
expr . . ]
end

- 371 -
La sintaxis anterior implica que podemos poner una serie de clausulas rescue
especificando diferentes tipos de errores que pueden ser rescatados y la clausula
else recibira aquellos errores que no entren dentro de los especificados por
rescue.

La clansula ensure es usada para especificar cdigo que queremos que se ejecute
independientemente del error generado. Por ejemplo:

begin
# Error...
rescue
# intento de recuperacin...
retry # tratar de nuevo
ensure
# Este cdigo es siempre ejecutado
end

Ejemplos:

def r ai se_except i on
put s ' Ant es de r ai se. '
raise ' Ocur r i o un er r or '
put s ' Despus de r ai se'
end
r ai se_except i on

def r ai se_y_r escue
begin
put s ' Ant es de r ai se. '
raise ' Ocur r i o un er r or . '
put s ' Despus de r ai se. '
rescue
put s ' Si endo r escat ado. '
end
put s ' Despues del bl oque begi n - end. '
end
r ai se_y_r escue

- 372 -

begin
# ...
rescue UnaExepci on
# ...
rescue Ot r oTi poDeExepci on
# ...
else
# Otras exceciones
end

begin
raise " Pr obando excepci ones. "
rescue Except i on => e
put s " Sal i da: "
put s e. message
put s e. backt r ace. i nspect
put s " f i n sal i da. "
end

x = a/ b rescue put s( " Di vi si on ent r e cer o! " )

Jerarqua de Excepciones

Las excepciones en Ruby dependen de una jerarqua de herencia la cual tiene
como superclase a Exception [30]:

* Exception
o NoMemoryError
o ScriptError
+LoadError
+NotImplementedError
- 373 -
+SyntaxError
o SignalException
+Interrupt
o StandardError (default for rescue)
+ArgumentError
+IOError
#EOFError
+IndexError
+LocalJ umpError
+NameError
#NoMethodError
+RangeError
#FloatDomainError
+RegexpError
+RuntimeError (default for raise)
+SecurityError
+SystemCallError
#Errno::*
+SystemStackError
+ThreadError
+TypeError
+ZeroDivisionError
o SystemExit
o fatal

De igual forma es posible derivar algunas de las clases de la jerarquia de
excepciones para crear una excepcin ms especializada.

Catch & Throw

Es posible en Ruby usar tambin los clsicos catch & throw los cuales son usados
comnmente cuando es necesario saltar de un punto de anidamiento ms
profundo [12].

- 374 -
Sintaxis:

catch ( :label) do
#...
end

throw :label #salta atrs hasta el catch correspondiente y
ejecuta el bloque

Ejemplo:

def pr egunt a pr
pr i nt pr
r es = r eadl i ne. chomp
throw :salida_solicitada if r es == " ! "
r es
end

catch :salida_solicitada do
nombr e = pr egunt a " Nombr e: "
edad = pr egunt a " Edad: "
sexo = pr egunt a " Sexo: "
# ...
end

throw puede ser usado en mltiples niveles de anidamiento. Es importante usar el
manejo de excepciones realmente para comportamientos que no vayan con el
flujo normal del programa.

- 375 -
Introduccin a Multihilos en Java

Aunque de manera estricta todos los programas de J ava manejan ms de un
hilo, de vista al usuario los programas por lo general son de un nico hilo de
control (flujo nico). Sin embargo pueden contar con varios hilos de control (flujo
mltiple).

Existen dos formas de implementar hilos en un programa de J ava. La forma
ms comn es mediante herencia, extendiendo la clase Thread.

Programas de flujo mltiple

Los programas en J ava implementan un flujo nico de manera implcita. Sin
embargo, J ava posibilita la creacin y control de hilos explcitamente. La
utilizacin de hilos en J ava, permite una enorme flexibilidad a los programadores
a la hora de plantearse el desarrollo de aplicaciones. La simplicidad para crear,
configurar y ejecutar hilos, permite que se puedan implementar muy poderosas y
portables aplicaciones y/o applets.

Las aplicaciones multihilos utilizan muchos contextos de ejecucin para
cumplir su trabajo. Hacen uso del hecho de que muchas tareas contienen
subtareas distintas e independientes. Se puede utilizar un hilo para cada subtarea.

Mientras que los programas de flujo nico pueden realizar su tarea
ejecutando las subtareas secuencialmente, un programa multihilos permite que
cada hilo comience y termine tan pronto como sea posible. Este comportamiento
presenta una mejor respuesta a las necesidades de muchas aplicaciones.

Veamos un ejemplo de un pequeo programa multihilos en J ava.

- 376 -

Ejemplo:

class Mi Hi l o extends Thread {

public Mi Hi l o ( St r i ng nombr e) {
super ( nombr e) ;
}

public void r un( ) {
for( int i =0; i <4; i ++) {
Syst em. out. pr i nt l n( get Name( ) + " " + i ) ;
try {
sleep( 400) ;
} catch( I nt er r upt edExcept i on e) { }
}
}
}

public class Mul t i Hi l o {
public static void mai n( St r i ng ar r g[ ] ) {
Mi Hi l o mascar = new Mi Hi l o( " Mascando" ) ;
Mi Hi l o si l bar = new Mi Hi l o( " Si l bar " ) ;
mascar . st ar t ( ) ;
si l bar . st ar t ( ) ;
}
}

Este pequeo ejemplo ejecuta dos hilos. Uno llamado mascar y otro silbar.
Por lo que el programa es capaz de "mascar" y "silbar" al mismo tiempo, aunque
como ya sabemos, en una computadora de un solo procesador tendr que dejar de
mascar para poder silbar, y viceversa.

- 377 -
Estados de un hilo

Cada hilo de ejecucin en J ava, es un objeto que puede estar en diferentes
estados.

Ejecutndose
Muerto
Esperando Durmiendo Bloqueado Esperando Durmiendo Bloqueado
finalizando
entrando a
no-ejecutable

Podemos apreciar que cuando un hilo es creado, no quiere decir que se
encuentre corriendo, sino que esto sucede cuando es invocado el mtodo start()
del objeto. Es hasta entonces que se encuentra en un estado de "Listo para
ejecutarse".

Cuando un hilo est ejecutndose pueden pasar varias cosas con ese hilo en
particular. El mtodo start() llama en forma automtica al mtodo run(). Este
mtodo contiene el cdigo principal del hilo, algo as como un mtodo main para
un programa principal.

Un hilo que est en ejecucin puede pasar a un estado de muerto si termina
de ejecutar al mtodo run( ).

El estado de "no-ejecutable". Se llega a este estado cuando el hilo no esta
"en ejecucin", debido a una llamada del mtodo sleep(), wait() o porque se est
realizando un proceso de entrada/salida que tarda cierto tiempo en ejecutarse.

- 378 -
Existen los mtodos stop(), suspend() y resume(), pero estos han sido
desaprobados en la versin 2 de J ava debido a que se consideran potencialmente
peligrosos para la ejecucin de los programas concurrentes.
46

Veamos ahora un diagrama que muestra de manera ms completa los
estados en los que puede estar un hilo.

nacido
listo
en ejecucin
dormido en espera bloqueado
expira el intervalo
de sleep
despachar
(asignar un
procesador)
expiracin
de cuanto
start
notify
notifyAll
Finalizada e/s
Emitir
solicitud de e/s
sleep
wait
muerto
Fin de
ejecucin

46
El que sean desaprobados no quiere decir que ya no puedan ser usados. Se conservan por compatibilidad
hacia atrs con el lenguaje, pero se ha visto que no es recomendable su uso. En algunos ejemplos pueden
aparecer estas instrucciones por simplicidad.
- 379 -
La clase Thread

El programa de ejemplo que se vio antes, corresponde a la forma de
implementacin ms comn de un hilo: mediante la extensin de la clase Thread.
Por lo que se pudo apreciar, la sintaxis para la creacin de un hilo seria:

class Mi Hi l o extends Thread {
public void r un( ) {
. . .
}
}

Esta tcnica, extiende a la clase Thread, y redefine el mtodo run(), el cual
debe contener un implementacin propia, de acuerdo a lo que se quiera que
realice el hilo.

Vamos a mencionar ahora los principales mtodos de la clase.
47

Thread(String
nombreThread)
Constructor de la clase Thread, recibe una
cadena para el nombre del hilo.
Thread( ) Constructor sin parmetros. Crea de
manera automtica nombres para los hilos.
Llamados Thread1, Thread2, etc.
start() Inicia la ejecucin de un hilo. Invoca al
mtodo run().
run() Este mtodo se redefine para controlar la
ejecucin del hilo.
sleep( tiempo ) Causa que el hilo se "duerma" un tiempo
determinado. Un hilo dormido no compite
por el procesador.
interrupt( ) Interrumpe la ejecucin de un hilo.
interrupted() Mtodo esttico que devuelve verdadero si

47
Para las caractersticas completas ver la documentacin: Java Platform API Specification

- 380 -
el hilo actual ha sido interrumpido.
isInterrupted() Mtodo no esttico que verifica si un hilo
ha sido interrumpido.
join( ) Espera a que un hilo especfico muera
antes de continuar. Est sobrecargado para
recibir un tiempo lmite de espera como
parmetro.
yield( ) El hilo cede la ejecucin a otros hilos.

Comportami ento de l os hi los

La implementacin real de los hilos puede variar un poco de una plataforma
a otra. Algunos sistemas como Windows, los hilos funcionan por rebanadas de
tiempo y otros como muchas versiones de Unix no tienen esta caracterstica.

En los sistemas que se manejan rebanadas de tiempo, los hilos de igual
prioridad se reparten el tiempo de ejecucin en partes iguales. En los sistemas que
no tienen rebanadas de tiempo, un hilo se ejecuta hasta que cede el control
voluntariamente, se lo quita un hilo de mayor prioridad, o termina su ejecucin.

Bajo este ltimo esquema, es importante que un hilo delegue el control cada
determinado tiempo a hilos de igual prioridad. Para esto sirve poner a dormir el
hilo con sleep(), o ceder el control con el mtodo yield(). Un mtodo que tiene
estas consideraciones se conoce como hilo compartido, el caso contrario se
conoce como hilo egosta.

Tener en cuenta que el mtodo yield() cede el control a hilos de la misma
prioridad. Esto es til en plataformas que no cuenten con rebanadas de tiempo,
pero no tiene sentido en sistemas que si cuentan con esta tcnica.
48

Veamos una clase que implementa un hilo y cede el control a otros hilos.

48
Sin embargo debera siempre considerarse el uso de yield() si se piensa en sistemas multiplataformas.
- 381 -
Ejemplo:

class Hi l oEt er no extends Thr ead {

public Hi l oEt er no ( St r i ng nombr e) {
super ( nombr e) ;
}

public void r un( )
{
int i =0;

while ( true) / / I t er ar par a si empr e
{
Syst em. out. pr i nt l n( get Name( ) + " " +" Ci cl o " + i ++) ;
if ( i %100==0)
yield( ) ; / / Ceder el pr ocesador a ot r os hi l os
}
}
}

public class Mul t i Hi l o2 {
public static void mai n( St r i ng ar r g[ ] ) {
Hi l oEt er no i nf i ni t o = new Hi l oEt er no( " Al i nf i ni t o" ) ;
Hi l oEt er no masAl l a = new Hi l oEt er no( " y mas al l a" ) ;
i nf i ni t o. st ar t ( ) ;
masAl l a. st ar t ( ) ;
}
}

- 382 -

- 383 -
Interfaz Grfica AWT

La independencia de la plataforma de J ava se vuelve a poner de manifiesto a
la hora de crear las interfaces grficas con el usuario. En otros lenguajes, si se
quiere hacer un programa que corra en distintas plataformas, una de las partes
ms crticas es precisamente el de la interfaz con el usuario.

En J ava, el paquete Abstract Windowing Toolkit, mejor conocido como
AWT, es el que proporciona las clases para el manejo de la interfaz, las cuales
son independientes de la plataforma. As, es posible definir ventanas, cuadros de
dilogo, botones o el elemento grfico que se necesite, y es representado en cada
sistema como si se tratara de un elemento nativo.
49

Como el AWT se trata de un paquete que no esta incluido implcitamente en
el lenguaje, es necesario indicarle al compilador cual es su ubicacin:


Dentro del AWT existen un gran nmero de clases con capacidades grficas,
componentes y elementos para el manejo de eventos. La informacin completa de
cada clase se puede consultar en la documentacin del jdk de J ava.

Clases de ventana

Para crear una aplicacin grfica, es necesario crear un objeto de tipo
ventana. El AWT ofrece una clase Window que define a un objeto genrico
ventana. Esta clase tiene como subclases principales a la clase Frame y la clase
Dialog.

La clase Window implementa los mtodos generales de una ventana, pero
carece de borde o de barra de mens en el momento de su creacin.

49
Existe tambin conjunto de clases llamadas Swing, que se prev que sustituyan al AWT ya que permiten
manipular y respetar el look and feel de cada ambiente grfico.
- 384 -
Clase Frame

Esta clase es usada comnmente para proporcionar la ventana principal de
una aplicacin. Es una subclase de Window y adems implementa la interfaz
MenuContainer, por lo que es capaz de trabajar con objetos de men de la clase
MenuBar.

La clase Frame aade mtodos de acceso para la obtencin y
establecimiento del ttulo de la ventana, la imagen del icono y la barra de mens,
entre otros. Adems define dos constructores, uno sin parmetros y otro que
recibe una cadena para determinar el ttulo de la ventana.

Clase Dialog

Esta tambin es una subclase de Window, y es utilizada para implementar
ventanas de cuadro de dilogo. Los cuadros de dialogo pueden ser modales o no
modales. Un cuadro de dilogo modal no regresa el control a la aplicacin hasta
que no se cierra el cuadro de dilogo.

Clase Filedialog

Este es un tipo especial de cuadro de dilogo, y es usada para crear cuadros
de dilogo de seleccin de archivos para entrada o salida. A travs de las
constantes LOAD o SAVE en un parmetro del constructor se puede ajustar el
comportamiento del cuadro de dilogo. Ofrece mtodos de acceso al nombre del
archivo y su ruta, y la posibilidad de especificar un filtro para la vista de archivos.

Ejemplo:

/ / cl ase Hol aVent anas
import j ava. awt . event . *;

- 385 -

public class Hol aVent anas extends Fr ame {
Hol aVent anas app = new Hol aVent anas( ) ;
}

public Hol aVent anas( ) {
super( " Hol a Vent anas! " ) ; / / asi gna t i t ul o a l a vent ana
set Si ze( 200, 200) ; / / def i ne el t amao de l a vent ana
addWi ndowLi st ener ( new
Hol aVent anas. Wi ndowEvent Handl er ( ) ) ; / / asoci a a l os event os de
l a vent ana
set Vi si bl e( true) ; / / muest r a l a vent ana en pant al l a

}

public void pai nt ( Gr aphi cs g) {
g. dr awSt r i ng( " Hol a Vent anas! " , 50, 90) ;
}

class Wi ndowEvent Handl er extends Wi ndowAdapt er {
public void wi ndowCl osi ng( Wi ndowEvent e) { / / asoci a
al event o de cer r ar vent ana
Syst em. exit( 0) ; / / con
l a sal i da del pr ogr ama
}
}
}

Esta clase extiende a la clase Frame, y de esta forma hereda la funcionalidad
bsica de una ventana de aplicacin.

Componentes grfi cos

Veamos ahora una aplicacin ms grande y funcional, que incluya algunos
componentes grficos bsicos como los campos de texto (TextField), etiquetes
(Label) y botones (Button), los cuales son slo algunos de los elementos grficos
proporcionados por J ava.
- 386 -

Ejemplo:

/ / Cl ase Cal Ahor r o

public class Cal Ahor r o extends Fr ame {

TextField campo_i nt er es = new Text Fi el d( " " , 15) ;
TextField campo_ani os = new Text Fi el d( " " , 15) ;
TextField campo_pago = new Text Fi el d( " " , 15) ;
Label cant _t ot al = new Label ( " " , Label . LEFT) ;
Button bot on = new But t on( " Cal cul ar " ) ;

/ / Met odo par a cal cul ar el ahor r o t ot al
public double cal c_ahor r o( double i nt er es, double cant i dad,
int ani os)
{
int num_pagos = ani os * 12; / / numer o de pagos
double t asa_mensual = 1. 0 + i nt er es / 1200. 0; / / t asa +
1. 0
double t ot al = 0;

/ / Cal cul ar el ahor r o t ot al
for ( int i = 0; i < num_pagos; i ++)
{
t ot al += cant i dad;
t ot al *= t asa_mensual ;
}

/ / Regr esar el ahor r o t ot al mas l os i nt er eses
return( t ot al ) ;
}

public Cal Ahor r o( St r i ng t i t ul o)
{
super( t i t ul o) ;
setLayout( new GridLayout( 5, 2, 3, 2) ) ;
/ / mt odos add aaden l os el ement os gr f i cos al obj et o
Layout de l a vent ana
- 387 -
add( new Label ( " Tasa de i nt er s anual %: " ,
Label . RIGHT) ) ;
add( campo_i nt er es) ;
add( new Label ( " Nmer o de Aos: " , Label . RIGHT) ) ;
add( campo_ani os) ;
add( new Label ( " Cont r i buci n Mensual $: " , Label . RIGHT) ) ;
add( campo_pago) ;
add( new Label ( " Ahor r o Tot al $: " , Label . RIGHT) ) ;
add( cant _t ot al ) ;
add( new Label ( ) ) ;
add( bot on) ;
}

public static void mai n( St r i ng ar gs[ ] )
{
Cal Ahor r o apl i caci on = new Cal Ahor r o( " Cal Ahor r o" ) ;
apl i caci on. pack( ) ; / / aj ust a l a vent ana al t amao m ni mo
en que se muest r en t odos l os component es gr f i cos
apl i caci on. setVisible( true) ; / / muest r a l a vent ana
}

public boolean act i on( Event evt , Obj ect ar g)
{
double i nt er es, cant _mensual , ahor r o_t ot al ;
int ani os;

if ( evt . t ar get == bot on)
{ / / Obt ener l os dat os del usuar i o
i nt er es =
Doubl e. valueOf( campo_i nt er es. get Text ( ) ) . doubl eVal ue( ) ;
cant _mensual = Doubl e. valueOf(
campo_pago. get Text ( ) ) . doubl eVal ue( ) ;

ani os=I nt eger . valueOf( campo_ani os. get Text ( ) ) . i nt Val ue( ) ;

/ / Cal cul ar el ahor r o t ot al
ahor r o_t ot al = cal c_ahor r o( i nt er es, cant _mensual ,
ani os) ;

/ / Poner el r esul t ado en l a et i quet a
- 388 -
cant _t ot al . set Text ( St r i ng. valueOf( ahor r o_t ot al ) ) ;
return true; / / event o pr ocesado
}
return false; / / event o no pr ocesado
}

public boolean handl eEvent ( Event evt )
{
if ( evt . i d == Event . WINDOW_DESTROY)
Syst em. exit( 0) ; / / t er mi nar l a apl i caci n

return super. handl eEvent ( evt ) ;
50

}
}

Esta aplicacin muestra el uso de los componentes grficos bsicos, cada
uno de ellos cuenta con un conjunto de miembros para su manipulacin y adems
estos componentes son colocados sobre un objeto de tipo Layout, como se aprecia
en la instruccin:

setLayout( new GridLayout( 5, 2, 3, 2) ) ;

Veamos ahora otro ejemplo, el cual a travs de un objeto Choice permite la
seleccin de los diferentes tipos de cursores que son definidos en Frame como
constantes estticas. El cambio de cursor se logra a travs del mtodo:

voi d setCursor( i nt t i poApunt ador )

Ejemplo:
/ / cl ase Apunt ador

public class Apunt ador extends Fr ame {

St r i ng el ement os[ ] = {" DEFAULT" , " CROSSHAI R" , " TEXT" , " WAI T" ,

50
El mtodo handleEvent pertenece al sistema antiguo de manejo de eventos, pero an es soportado.
- 389 -
" SW_RESI ZE" , " SE_RESI ZE" , " NW_RESI ZE" , " NW_RESI ZE" ,
" NE_RESI ZE" , " N_RESI ZE" , " S_RESI ZE" , " W_RESI ZE" , " E_RESI ZE" ,
" HAND" , " MOVE" };

int apunt ador es[ ] ={ Fr ame. DEFAULT_CURSOR,
Fr ame. CROSSHAI R_CURSOR,
Fr ame. TEXT_CURSOR, Fr ame. WAI T_CURSOR,
Fr ame. SW_RESI ZE_CURSOR,
Fr ame. SE_RESI ZE_CURSOR,
Fr ame. NW_RESI ZE_CURSOR,
Fr ame. NW_RESI ZE_CURSOR,
Fr ame. NE_RESI ZE_CURSOR,
Fr ame. N_RESI ZE_CURSOR,
Fr ame. S_RESI ZE_CURSOR,
Fr ame. W_RESI ZE_CURSOR,
Fr ame. E_RESI ZE_CURSOR, Fr ame. HAND_CURSOR,
Fr ame. MOVE_CURSOR };

Choice menu = new Choi ce( ) ;

public Apunt ador ( St r i ng t i t ul o)
{

for ( int i = 0; i < el ement os. l engt h; i ++)
menu. addItem( el ement os[ i ] ) ;

add( " Nor t h" , menu) ; / / aade obj et o en l a par t e
super i or de l a vent ana
}

public static void mai n( St r i ng ar gs[ ] )
{
Apunt ador apl i caci on = new Apunt ador ( " Apunt ador es" ) ;
apl i caci on. set Si ze ( 250, 150) ;
apl i caci on. setVisible( true) ;
}

{
- 390 -
if ( evt . t ar get instanceof Choi ce)
{
setCursor( apunt ador es[ menu. getSelectedIndex( ) ] ) ;
}
}

public boolean handl eEvent ( Event evt )
{
Syst em. exit( 0) ; / / t er mi nar l a apl i caci on

}
}

Apli caciones con mens

Es comn que una aplicacin grfica necesite de mens como una forma de
ofrecer distintas posibilidades de operacin del programa de acuerdo a la solicitud
del usuario. Para esto se incluyen clases que permiten el manejo de mens.

Clase MenuBar

Esta clase permite la creacin de una instancia barra de mens, la cual se
asocia al objeto de tipo Frame a travs del mtodo setMenuBar(). La barra de
men es donde se colocarn posteriormente cada una de las opciones principales
del men de la aplicacin. Un ejemplo de la creacin de una barra de men se
presenta a continuacin:

MenuBar bar r a_menu = new MenuBar ( ) ;
f . setMenuBar( bar r a_menu) ;

Clase Menu

- 391 -
Una vez que se tiene la barra de men, es necesario crear objetos de la clase
Menu, uno por cada opcin de men deseada. Posteriormente estos objetos se
asocian a la barra de men:

Menu menu_ar chi vo = new Menu( " Ar chi vo" ) ;
Menu menu_edi t ar = new Menu( " Edi t ar " ) ;
menubar . add( menu_ar chi vo) ;
menubar . add( menu_edi t ar ) ;

Clase MenuItem

Cada men tiene comnmente un conjunto de opciones. Estas pueden
crearse asociando instancias de la clase MenuItem, de la siguiente forma:

menu_ar chi vo. add( new MenuItem( " Abr i r " ) ) ;
menu_ar chi vo. add( new MenuItem( " Guar dar " ) ) ;
menu_edi t ar . add( new MenuItem( " Cor t ar " ) ) ;

Aunque el mtodo add() de los objetos de la clase Menu esta sobrecargado
para aceptar una cadena e implcitamente se creara un objeto MenuItem
internamente, por lo que el segmento de cdigo anterior puede ser escrito de la
siguiente forma:

menu_ar chi vo. add( " Abr i r " ) ;
menu_ar chi vo. add( " Guar dar " ) ;
menu_edi t ar . add( " Cor t ar " ) ;

Ejemplo:

/ / cl ase Pr uebaMenu

public class Pr uebaMenu extends Fr ame {
/ / f al se en l ugar de t r ue agr ega l a opci n en modo desact i vado
Menu ar chi vo = new Menu( " Ar chi vo" , true) ;
Menu edi t ar = new Menu( " Edi t ar " , true) ;
- 392 -

public Pr uebaMenu( St r i ng t i t ul o) {
set MenuBar ( bar r a_menu) ;
bar r a_menu. add( ar chi vo) ;
bar r a_menu. add( edi t ar ) ;
ar chi vo. add( " Nuevo" ) ;
ar chi vo. add( " Abr i r " ) ;
ar chi vo. add( " Guar dar " ) ;
edi t ar . add( " Cor t ar " ) ;
edi t ar . add( " Copi ar " ) ;
edi t ar . add( " Pegar " ) ;
}

Pr uebaMenu apl i caci on = new Pr uebaMenu( " pr ueba_menu" ) ;
apl i caci on. set Si ze( 250, 125) ;
}

public boolean handl eEvent ( Event evt ) {
Syst em. exit( 0) ;
}

{
if ( evt . t ar get instanceof MenuI t em) {
if ( ar g. equal s( " Abr i r " ) )
Syst em. out. pr i nt l n( " Opci n Ar chi vo / Abr i r " ) ;
else if( ar g. equal s( " Guar dar " ) )
Syst em. out. pr i nt l n( " Opci n Ar chi vo / Guar dar " ) ;

/ / Repet i r l a compar aci n par a l as dems opci ones
}
}
}

- 393 -
Ejemplo de la clase Filedialog:
/ / cl ase Pr uebaFi l eDi al og

public class Pr uebaFi l eDi al og extends Fr ame {

Menu menu_ar chi vo = new Menu( " Ar chi vo" , true) ;

public Pr uebaFi l eDi al og( St r i ng t i t ul o) {
set MenuBar ( bar r a_menu) ;
bar r a_menu. add( menu_ar chi vo) ;
menu_ar chi vo. add( " Abr i r " ) ;
}

Pr uebaFi l eDi al og apl i caci on = new
Pr uebaFi l eDi al og( " pr ueba Fi l eDi al og" ) ;
apl i caci on. set Si ze( 200, 100) ;
}

public boolean handl eEvent ( Event evt ) {
Syst em. exit( 0) ;
}

public boolean act i on( Event evt , Obj ect ar g) {
if ( evt . t ar get instanceof MenuI t em) {
if ( ar g. equal s( " Abr i r " ) ) {
FileDialog f d = new Fi l eDi al og( this, " Abr i r
Ar chi vo" ) ;
f d. setVisible( true) ;
Syst em. out. pr i nt l n( " Di r ect or i o: " +
f d. getDirectory( ) ) ;
Syst em. out. pr i nt l n( " Ar chi vo: " + f d. getFile( ) ) ;
}
return true;
- 394 -
}
return false;
}
}

Manejo de Eventos
Introducci n

El diseo de interfaces grficas obliga a tomar en cuenta el manejo de
eventos. Existe un modelo de manejo de eventos que ha sido desaprobado desde
la versin 1.1 del jdk.

El mecanismo de eventos de la versin 1.0 era considerado rudimentario, y
estaba inspirado de la estructura de manejo de eventos de la ToolBox de
Macintosh. La solucin sirve para programas pequeos, pero en aplicaciones ms
complejos aparecen algunas deficiencias:

El sistema de subclasificacin de componentes ha dado lugar a una
creacin excesiva de clases derivadas de los componentes estndar
nicamente por la necesidad de manejar los eventos, cuando slo debera
utilizarse la herencia para una apariencia grfica especfica o un
comportamiento funcional distinto.

No se permite una separacin clara entre la interfaz de usuario y los
tratamientos funcionales que tiene asociados, por lo que los componentes
creados no son reutilizables.

Utilizar un mismo mtodo para manejar todos los eventos de tipos
diferentes implica numerosos problemas de depuracin.

No se pueden filtrar los eventos. Estos se distribuyen sistemticamente a
los componentes, tanto si los manejaban o no. Esto implica una reduccin
notable de velocidad cuando el nmero de eventos era muy grande.
- 395 -

Los mtodos action() mandan una cadena de caracteres para indicar el
ttulo del componente fuente del evento o la lnea seleccionada,
ocasionando algunos problemas de codificacin poco confiable debido a
las comparaciones de cadenas de caracteres.
Model o de manej o de eventos actual

El principio esencial del nuevo modelo se basa en la delegacin. Los
componentes delegan el manejo de los eventos de usuario a una clase externa.
Este modelo responde a las crticas del anterior:

Ya no es necesario crear una clase por componente.

Cada componente de la interfaz slo transmitir a la aplicacin los eventos
que espera. Se efecta de modo predeterminado un filtrado inteligente.

Es posible separar claramente los tratamientos funcionales de los eventos de
la interfaz de usuario, permitiendo as una verdadera reutilizacin de los
componentes grficos por un lado, y de las clases funcionales por otro lado.

El funcionamiento del nuevo modelo es un poco ms complejo, de acuerdo
al esquema de la figura anterior:
java.util.EventObject
Origen
del
Origen del
evento
Delegado para
el evento
Evento
<<interfaz>>
java.util.EventListener
- 396 -

Los eventos son objetos que derivan de la clase java.util.EventObject.
Existe ahora una jerarqua de eventos (ver figura 3).

Un origen de eventos, en general un componente grfico derivado de
Component, emite un evento hacia un delegado capaz de tratarlo.

El delegado indica que est interesado por un evento en particular
implementando una o ms interfaces especficas derivadas de
java.util.EventListener.

Para enlazar al origen del evento y al delegado, el delegado debe
previamente estar registrado en el origen. Por lo que el origen debe definir
mtodos de registro de los delegados de acuerdo a una de las dos siguientes
formas:

publ i c <Ti poEvent o>Li st ener set<Ti poEvent o>Li st ener
( <Ti poEvent o>Li st ener mi Del egado)

publ i c <Ti poEvent o>Li st ener add<Ti poEvent o>Li st ener
( <Ti poEvent o>Li st ener mi Del egado)

donde la primera opcin es utilizada para una difusin hacia un solo
delegado
51
; mientras que la segunda permite la difusin hacia mltiples
delegados
52
.

El tipo de evento correspondera a una clase derivada de
java.util.EventObject, como eventos de mouse (MouseListener) o eventos de
accin (ActionListener). Una lista completa de la jerarqua de eventos puede verse
en la documentacin de J ava.

51
Tambin llamada difusin simple.
52
Difusin mltiple.
- 397 -
Veamos un programa que nicamente contiene un botn, el cual al
presionarse cierra la aplicacin.

Ejemplo:

/ / pr ogr ama Ej empl oEvent o1

public class Ej empl oEvent o1 extends Fr ame {

public Ej empl oEvent o1( ) {
But t on mi Bot on= new But t on( " bot on" ) ;

/ * El met odo si gui ent e r egi st r a al del egado en el bot on
t r as haber l o cr eado. Todos l os component es est andar del AWT
per mi t en l a di f usi n ml t i pl e, es por est o que sol o exi st en
met odos de t i po add<Ti po>Li st ener */
mi Bot on. addActionListener( new Mi Del egado( ) ) ;

add( mi Bot on) ;
}

Ej empl oEvent o1 f = new Ej empl oEvent o1( ) ;

f . pack( ) ;
f . set Vi si bl e( true) ; / / puede ser usado en l ugar de show( )
}
}

/ / est a es l a cl ase del egada, que gest i ona l os event os sobr e el
r at on
class Mi Del egado implements ActionListener {

- 398 -
public void act i onPer f or med( Act i onEvent e ) {
Syst em. exit( 0) ;
}
}

Esta clase MiDelegado, podra convertirse en una clase annima que
estuviera definida dentro de la clase EjemploEvento1.

Ejemplo:


public class Ej empl oEvent o2 extends Fr ame {

But t on mi Bot on= new But t on( " bot on" ) ;
mi Bot on. addAct i onLi st ener (
/ / se cr ea una cl ase anoni ma que i mpl ement a
Act i onLi st ener
new ActionListener ( ) {

public void actionPerformed( ActionEvent e ){
System.exit(0);
}
}
) ;

add( mi Bot on) ;
}

Ej empl oEvent o2 f = new Ej empl oEvent o2( ) ;

f . pack( ) ;
f . set Vi si bl e( true) ;
- 399 -
}
}

Esta clase tambin generar un archivo class, pero se le asignar despus del
nombre de la clase un nmero que la identifique.

Adaptadores

En aplicaciones ms grandes, es necesario aadir una clase intermedia, que
servir de intermediario entre el objeto fuente y el delegado. Esto permite separar
an mejor la interfaz del usuario del cdigo de manejo de eventos, permitiendo un
mayor grado de reuso.

Adems, el adaptador permite efectuar operaciones complementarias sobre
los eventos.

Un adaptador tiene como funcin mnima implementar la interfaz o
interfaces de los eventos que quiere vigilar.

Veamos ahora otro programa similar al presentado inicialmente, pero
contiene adems un botn para maximizar la ventana. Se aade una clase nica
adaptador que permite desviar los mensajes hacia el delegado.

Ejemplo:


public class Ej empl oEvent o3 extends Fr ame{


/ / se cr ea un del gado par a est a i nt er f az
Mi Del egado unDel egado = new Mi Del egado( ) ;

- 400 -
/ / se cr ea el bot on sal i r
But t on mi Bot onSal i r = new But t on( " Sal i r " ) ;

/ / se l e asi gna un adapt ador
mi Bot onSal i r . addAct i onLi st ener ( new
Mi Adapt ador ( Mi Adapt ador . SALIR, unDel egado) ) ;

/ / se hace l o mi smo con el bot on maxi mi zar
But t on mi Bot onMaxi mi zar = new But t on( " Maxi mi zar " ) ;
mi Bot onMaxi mi zar . addAct i onLi st ener ( new
Mi Adapt ador ( Mi Adapt ador . MAXIMIZA, unDel egado) ) ;

/ / se aaden l os bot ones en l a i nt er f az
set Layout ( new Fl owLayout ( ) ) ;
add( mi Bot onSal i r ) ;
add( mi Bot onMaxi mi zar ) ;

}

/ / el met odo pr i nci pal no cambi a
Ej empl oEvent o3 f =new Ej empl oEvent o3( ) ;
f . pack( ) ;
f . set Vi si bl e( true) ;

}
}

/ / el del egado posee dos met odos f unci onal es
class Mi Del egado {

public void sal i r Apl ( ) {
Syst em. exit( 0) ;

}
public void maxi mi zar ( Fr ame f ) {
f . set Si ze( f . get Tool ki t ( ) . get Scr eenSi ze( ) ) ;
}
}
- 401 -

/ / el adapt ador ef ect ua l a desvi aci on
class Mi Adapt ador implements Act i onLi st ener {
public static final int SALIR = 1;
public static final int MAXIMIZA = 2;
protected int t i poAcci on; / / l a acci on af ect a al
adapt ador
protected Mi Del egado el Del egado; / / el del egado que
t r at ar a l a aci on

public Mi Adapt ador ( int unTi poAcci on, Mi Del egado
unDel egado) {
t i poAcci on = unTi poAcci on;
el Del egado = unDel egado;

}
public void act i onPer f or med( Act i onEvent e) {

/ / se r ecuper a l a vent ana f uent e del event o: se sube
por l a cadena
/ / de component es, hast a encont r ar una i nst anci a de l a
cl ase Wi ndow
Obj ect unComponent e = e. get Sour ce( ) ;
do{
unComponent e = ( ( Component )
unComponent e) . get Par ent ( ) ;

}while ( ! ( unComponent e instanceof Wi ndow) ) ;

Wi ndow vent anaPr i nci pal = ( Wi ndow) unComponent e;

switch ( t i poAcci on) {
case SALIR:
/ / se l l ama el met odo sal i r Apl del del egado
el Del egado. sal i r Apl ( ) ;
break;
case MAXIMIZA:
/ / se l l ama al met odo maxi mi zar pasando el
Fr ame que cont i ene el component e sobr e el que se ha pr oduci do
el event o.
- 402 -
el Del egado. maxi mi zar ( ( Fr ame)
vent anaPr i nci pal ) ;
break;
}
}
}

El ejemplo anterior, no parece brindar ventajas en relacin al cdigo o ser
ms compresible que el manejo de eventos del modelo anterior; sin embargo, es
ms robusto en aplicaciones grandes. Pudiera adems tenerse una mejor
distribucin del cdigo, identificando claramente la parte de la interfaz con el
usuario del cdigo de resolucin de eventos.

Ejemplo:

/ / Pr ogr ama Ej empl oEvent o4. j ava

/ / l a cl ase pr i nci pal es l a apl i caci on, y si r ve de del egado.
public class Ej empl oEvent o4 {

/ / cont i ene l os dos met odos f unci onal es
public void sal i r Apl ( ) {
Syst em. exit( 0) ;
}

public void maxi mi zar ( Fr ame f ) {
f . set Si ze( f . get Tool ki t ( ) . get Scr eenSi ze( ) ) ;
}


/ / se i nst anci a l a apl i caci on
Ej empl oEvent o4 mi Apl = new Ej empl oEvent o4( ) ;

/ / se cr ea el obj et o de i nt er f az con el usuar i o y se
enl aza con l a apl i caci on
I nt er f azUsuar i o mi I U = new I nt er f azUsuar i o( mi Apl ) ;
- 403 -
}
}

/ / est a cl ase const r uye l a i nt er f az de l a apl i caci on
class I nt er f azUsuar i o {

/ / su const r uct or posee como par amet r o l a apl i caci on a
l a que est a enl azada
public I nt er f azUsuar i o( Ej empl oEvent o4 unaApl ) {
Fr ame mi Fr ame = new Fr ame( " Apl i caci on" ) ;
mi Fr ame. set Layout ( new Fl owLayout ( ) ) ;

/ / se cr ea el bot on Sal i r
But t on mi Bot onSal i r = new But t on( " Sal i r " ) ;

/ / se l e asi gna un adapt ador
mi Bot onSal i r . addAct i onLi st ener ( new
Mi Adapt ador ( Mi Adapt ador . SALIR, unaApl ) ) ;

/ / se hace i gual con el bot on maxi mi zar
But t on mi Bot onMaxi mi zar =new But t on( " Maxi mi zar " ) ;
mi Bot onMaxi mi zar . addAct i onLi st ener ( new
Mi Adapt ador ( Mi Adapt ador . MAXIMIZA, unaApl ) ) ;

/ / se aaden l os bot ones en l a i nt er f az y se hace
l a vent ana vi si bl e
mi Fr ame. add( mi Bot onSal i r ) ;
mi Fr ame. add( mi Bot onMaxi mi zar ) ;
mi Fr ame. pack( ) ;
mi Fr ame. set Vi si bl e( true) ;
}
}

/ / el adapt ador ef ect ua l a desvi aci on
class Mi Adapt ador implements Act i onLi st ener {

static final int SALIR = 1;
static final int MAXIMIZA = 2;
protected int t i poAcci on; / / l a acci on asi gnada al
adapt ador
- 404 -
protected Ej empl oEvent o4 I Apl ; / / el del egado que t r at ar a
l a acci on

public Mi Adapt ador ( int unTi poAcci on, Ej empl oEvent o4
unaApl ) {
t i poAcci on = unTi poAcci on;
I Apl = unaApl ;
}

public void act i onPer f or med( Act i onEvent e) {

/ / se r ecuper a l a vent ana f uent e del event o: se sube
por l a cadena
/ / de component es, hast a encont r ar una i nst anci a de
l a cl ase Wi ndow
Obj ect unComponent e = e. get Sour ce( ) ;
do {
unComponent e = ( ( Component ) unComponent e
) . get Par ent ( ) ;
} while ( ! ( unComponent e instanceof Wi ndow) ) ;

Wi ndow vent anaPr i nci pal = ( Wi ndow) unComponent e;

switch ( t i poAcci on) {
case SALIR:

/ / se l l ama al met odo sal i r Apl del del egado
I Apl . sal i r Apl ( ) ;
break;
case MAXIMIZA:
/ / se l l ama al met odo maxi mi zar pasando el
Fr ame
/ / que cont i ene el component e sobr e el que
se ha pr oduci do el event o
I Apl . maxi mi zar ( ( Fr ame) vent anaPr i nci pal ) ;
break;
}
}
}

- 405 -

- 406 -
Se presenta una grfica mostrando la organizacin de paquetes y las
jerarquas de los eventos y de Listeners:

- 407 -
Otras tecnologas Java

J ava cuenta con otras tecnologas que apoyan la construccin de sistemas
distribuidos, y el objetivo es que para sistemas grandes se puedan combinar
dependiendo de las necesidades de cada una de las reas. Algunas de estas
tecnologas ya vienen soportadas por la edicin estndar de J ava (J AVA SME),
recordemos que existen tres ediciones del lenguaje:

Java SE. Java Platform Standard Edition, es la versin ms comn y popular
de J ava. Contiene los servicios estndar para applets y aplicaciones, entrada
salida, prestaciones para desarrollo de la interfaz grfica con el usuario, etc. La
mayor parte de lo visto sobre J ava se encuentra en esta edicin.

Java ME. Java Platform Micro Edition, es la plataforma de desarrollo para
dispositivos con soporte para J ava, como aparatos elctricos y dispositivos
mviles (Palm Pilot, celulares, pagers). Se trata de un subconjunto muy
restringido del lenguaje J ava y clases, buscando mejorar el rendimiento y
reducir los requerimientos de sus programas debido a las restricciones de estos
dispositivos.

Java EE. Java Platform Enterprise Edition, est basada en la versin estndar,
pero aade un conjunto de API's que permiten el desarrollo de clases de tipo
enterprise, dando mayor soporte a las aplicaciones servidor. Esta edicin de
J ava fue liberada apenas en diciembre de 1999, aunque algunas de las
tecnologas ya se encontraban disponibles desde antes.

En la figura se puede apreciar mejor como se ubican y complementan cada una
de las ediciones de J ava:

- 408 -

Ediciones de la plataforma de Java.
Princi pal es tecnol ogas de Java EE.

Se hace una breve mencin de las tecnologas con que cuenta J ava EE, de
forma que puedan ser tomadas en cuenta en la construccin de aplicaciones J ava.

EJB. Enterprise JavaBeans, es la arquitectura para desarrollo de componentes
del lado del servidor. Ofrece los estndares para crear componentes estndar,
construccin de interfaces entre distribuidores y clientes de software. De
alguna forma es la punta de lanza de la J AVA EE, y se apoya en otras API's de
esta edicin.

CORBA. CORBA es parte integral de J AVA EE, a travs de tres productos de
J ava: RMI-IIOP, Java IDL, y Java Transaction Service.

JNDI. Java Naming and Directory Interface, provee servicios de nombre y
directorios para poder ser integrados en applet y aplicaciones de
J ava. Se trata de un producto 100% J ava y es la solucin de Sun
de productos como X.500 de la ISO y NDS (Servicio de
- 409 -
Directorios Netware) de Novell. Ofrece capacidades de bsqueda de
componentes y recursos entre redes heterogneas.

JMS. Java Message Service, permite la comunicacin asncrona de objetos
distribuidos. J MS soporta los estilos de mensaje de publicacin / suscripcin o
punto a punto.

Servlets. Los servlets son la contraparte de los applets, mientras que estos
ltimos corren en el cliente, los servlets son pequeas aplicaciones que se
ejecutan del lado del servidor. Esto permite extender la funcionalidad de los
servidores de web ofreciendo programas basados en componentes e
independientes de la plataforma.

JSP. Java Server Pages, es la respuesta de J ava a las pginas ASP. Los J SP
son scripts compilados dentro de servlets
53
, pero con la diferencia de que los
J SP scripts no tienen cdigo J ava puro.

XML. Extensible Markup Language. Este es un estndar para estructurar el
contenido de documentos electrnicos, y est tomando bastante
fuerza en el mercado, y se supone que a la larga sustituya a
HTML. J ava EE ofrece soporte para XML; adems de que lo
puede usar en J SP's para darle formato a las pginas generadas
dinmicamente, los EJ B usa XML para describir componentes y J MS apoya el
envo de datos asncronos XML.

JDBC. La versin 2 de J DBC es incluida en parte en la edicin estndar, como
el soporte para SQL 3 (SQL 1999). Sin embargo, algunas caractersticas se
incluyen como una extensin a la edicin estndar: soporte a J NDI, manejo de
transacciones distribuidas y manejo de J avaBeans.

53
De hecho, JSP es una extensin de Java Servlets API.
- 410 -
Connector. Se trata de una arquitectura para ofrecer soluciones J ava de
conectividad entre mltiples servidores de aplicacin y sistemas de
informacin empresariales existentes.

Transaction. J ava EE simplifica el manejo de transacciones para aplicaciones
distribuidas, est constituido por dos especificaciones: J TA, Java Transaction
API, y J TS, Java Transaction Service. J TA permite que una aplicacin y un
servidor de aplicaciones manejen transacciones. J TS especifica la
implementacin de un administrador de transacciones con soporte J TA.

Otras tecnologas (no necesariamente Java)

Tecnol oga Google

GWT. El Google Web Kit es un kit de desarrollo para apicaciones web
tipo AJ AX, donde el programador desarrolla en J ava y es posible generar
cdigo J avaScript.
Google App Engine. Es un motor de aplicaciones de Google que permite
desarrollar aplicaciones web y ejecutarlas en la
infraestructura de Google. Por el momento el desarrollo es
en el lenguaje Python pero se esta tranajando en
soporte para lenguajes como J ava y Ruby.

Gears. Es un proyecto Open Source lidereado por Google que permite
almacenar informacin localmente habilitando la posibilidad de manejar
aplicaciones web fuera de lnea. Tambin permite ejecutar J avaScript en el
fondo (workerpools) de manera que se mejora la
ejecucin del navegador.

Android. Es un sistema operativo, middleware y aplicaciones bsicas para
dispositivos mviles. El desarrollo se hace en J ava con un API especfica
para este sistema.
- 411 -

APIs Diversas de Google. Google distribuye una serie de APIs para poder
desarroolar aplicaciones que utilicen sus recursos. Dentro de stas se
pueden mencionar: para AJ AX, para desarrollo de Gadgets, para manejo
de datos de Google, para YouTube, OpenSocial, manejo de Mapas

Lenguajes di nmicos y frameworks

Algunos de los principales frameworks usados para desarrollo Web:

Ruby on Rails. Es un framework gratuito para desarrollo
de aplicaciones Web en Ruby.

Django. Es un framework open source para
desarrollo de aplicaciones web usando Python.

Grails. Es un framework open source para el
lenguaje Groovy.

SproutCore. Es un framework open source para desarrllo de aplicaciones
web con J avaScript con el objetivo de crear aplicaciones web que se
comporten y sientan como aplicaciones de escritorio. Usa Ruby para
generar HTML esttico y archivos J avaScript. Es usado por Apple
(anunciado en 2008) paragenerar aplicaciones multiplataforma. De hecho,
MobileMe est desarrollado con este framework. Es la opcin de Apple
para competir con Flash y Silverlight.

- 412 -

Y ms l enguaj es

Groovy. Es un lenguaje orientado a objetos y dinmico,
similar a Python, Ruby, Perl y Smalltalk pero que es
dinmicamente compilado hacia bytecodes de la mquina
virtual de J ava.
JRuby. Es una implementacin en J ava del intrprete de Ruby. Su alta
integracin con J ava permite completo acceso en los dos sentidos entre
cdigo J ava y Ruby.
Jython/JPython. Una implementacin de Python
en J ava. Programas en J ython pueden importar y
usar clases en J ava.
Scala. Es un lenguaje multiparadigma que integra
caractersticas de orientado a objetos y programacin funcional. Se ejecuta
en la plataforma J ava y es compatible con programas en dicho lenguaje.
- 413 -

Referencias

1. Beaton, W. and McAffer, J ., Eclipse Rich Client Platform, Eclipse
Foundation, 2006,
http://www.eclipse.org/downloads/download.php?file=/technology/phoenix/
talks/What-is-Eclipse-and-Eclipse-RCP-3.2.6.ppt, Last access: J anuary 2007
2. Weitzenfeld, A., Paradigma Orientado a Objetos, Depto. Academico de
Computacion, ITAM, Mexico, 1994
3. Muller, P., Introduccion a la programacion orientada a objetos empleando
C++, Globewide Network Academy (GNA), 1997, http://uu-
gna.mit.edu:8001/uu-gna/text/cc/Tutorial//tutorial.html
4. Muller, P.-A. Modelado de Objetos con UML. Gestion 2000, Espaa, 1997.
5. Sun Microsystems, The J ava Language: An Overview, Sun Microsystems -
Java White Paper, 1997, Last access: April 2002
6. Wegner, P., Classification in Object-oriented Systems. In Proceedings of
1986 SIGPLAN workshop on Object-oriented programming, (New York,
USA, 1986), ACM Press, 173-182.
7. Budd, T. An introduction to object-oriented programming. Addison-Wesley
Pub. Co., Reading, Mass., 1991.
8. Programacin Orientada a Objetos en C++, Fundacin Arturo Rosenblueth,
Mxico, 1996.
9. Matsumoto, Y. Ruby in a nutshell : a desktop quick reference. O'Reilly,
Sebastopol, CA, 2002.
10. Fulton, H.E. The Ruby way. Addison-Wesley, Upper Saddle River, NJ ,
2007.
11. Deitel, H.M. and Deitel, P.J . C++ : how to program. Pearson/Prentice Hall,
Upper Saddle River, NJ , 2005.
12. Thomas, D., Fowler, C. and Hunt, A. Programming Ruby : the pragmatic
programmers' guide. Pragmatic Bookshelf, Raleigh, N.C., 2005.
13. Slagell, M., Ruby User's Guide, 2007,
http://www.rubyist.net/~slagell/ruby/, Last access: March 2008
- 414 -
14. Silver, P.A. THE BOSTON PHOENIX'S GUIDE TO CHEAP EATS:
INEXPENSIVE DINING IN GREATER BOSTON. Harvard Student
Agencies, 1975.
15. Rumbaugh, J . Object-oriented modeling and design. Prentice Hall,
Englewood Cliffs, N.J ., 1991.
16. Cruz Matas, I.A. and Fernndez-y-Fernndez, C.A., UMLGEC ++: Una
Herramienta CASE para la Generacin de Cdigo a partir de Diagramas de
Clase UML. In Proceedings of XVI Congreso Nacional y II Congreso
Internacional de Informtica y Computacin, (Zacatecas, Mxico, 2003),
ANIEI.
17. Cruz Matas, I.A. Herramienta CASE para la generacin de cdigo C++a
partir de diagramas de clase UML, Thesis, Instituto de Electrnica y
Computacin, Universidad Tecnolgica de la Mixteca, Huajuapan, 2003,
123 pp.
18. Fernndez-y-Fernndez, C.A. Modelado Visual con UML TEMAS de
Ciencia y Tecnologa, 2002, 54-58.
19. Booch, G., Rumbaugh, J . and J acobson, I. The unified modeling language
user guide. Addison-Wesley, Reading Mass., 1999.
20. Deitel, H.M. and Deitel, P.J . C how to program. Pearson Education, Upper
Saddle River, N.J ., 2007.
21. Vandevoorde, D. and J osuttis, N.M. C++ templates : the complete guide.
Addison-Wesley, Boston, MA, 2003.
22. Standard Template Library Programmer's Guide, Silicon Graphics -
Hewlett-Packard Company, 1994, http://www.sgi.com/tech/stl/, Last access:
J une 2007
23. Bracha, G., Generics in the J ava Programming Language Tutorial, Sun
Microsystems, Mar, 2004, http://java.sun.com/j2se/1.5/pdf/generics-
tutorial.pdf, Last access: J une 2007
24. Kreft, K. and Langer, A., Language Features of J ava Generics, Fawcette
Technical Publications, 2004,
http://www.ftponline.com/javapro/2004_03/online/jgen_kkreft_03_03_04/d
efault_pf.aspx, Last access: J une 2007
25. Turner, K., Catching more errors at compile time with Generic J ava, IBM
DeveloerWorks, 2001, http://www.ibm.com/developerworks/library/j-
genjava.html, Last access: J une 2007
- 415 -
26. Naftalin, M. and Wadler, P. Java generics and collections. O'Reilly, Beijing
; Sebastopol, CA, 2007.
27. Daz-Alejo Gmez, J .A., Programacin con J ava, IES Camp, Valencia,
Espaa, Last access: September 2006
28. Arnold, K., Gosling, J . and Holmes, D. Java (TM) Programming Language,
The. Addison-Wesley Professional, 2005.
29. Sun Microsystems, Programming With Assertions, Sun Microsystems, 2002,
http://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html, Last access: J une
2007
30. Davis, R., Ruby QuickRef, 2004,
http://www.zenspider.com/Languages/Ruby/QuickRef.html, Last access:
J une 2008

Notas POO 2008

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Notas POO 2008

Caricato da

Copyright:

Formati disponibili

PROGRAMACIN ORIENTADA

obj = Nombr eCl ase. new [ ( par met r os) ]

Potrebbero piacerti anche